diff --git a/.github/workflows/golangci-lint.yml b/.github/workflows/golangci-lint.yml index d2f42e2..4425898 100644 --- a/.github/workflows/golangci-lint.yml +++ b/.github/workflows/golangci-lint.yml @@ -9,16 +9,14 @@ permissions: contents: read jobs: - golangci: - name: lint + golangci-lint: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-go@v5 with: go-version: '1.21' - cache: false - - name: golangci-lint - uses: golangci/golangci-lint-action@v4 + - name: lint + uses: golangci/golangci-lint-action@v6.1.1 with: - version: v1.54 + version: latest diff --git a/.ogen.yml b/.ogen.yml new file mode 100644 index 0000000..f9b5a44 --- /dev/null +++ b/.ogen.yml @@ -0,0 +1,27 @@ +# sets parser options. +parser: + # enables type inference for schemas. Schema parser will try to detect schema type by its properties. + infer_types: true + # enables remote references resolving. See https://github.com/ogen-go/ogen/issues/385. + allow_remote: true + # is maximum depth of schema generation. Default is 1000. + depth_limit: 1000 + +# sets generator options. +generator: + # sets generator features. + features: + enable: + # Enables paths client generation + - 'paths/client' + # Enables client usage in security source implementations + - 'client/security/reentrant' + # Enables validation of client requests + - 'client/request/validation' + # Enables validation of server responses + - 'server/response/validation' + # Enables stub Handler generation + - 'ogen/unimplemented' + disable: + # Disables paths server generation + - 'paths/server' diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..8dae4a0 --- /dev/null +++ b/Makefile @@ -0,0 +1,6 @@ +.PHONY: generate-client + + +generate-client: + ogen -clean -config .ogen.yml -package tonapi -target . api/openapi.yml + diff --git a/README.md b/README.md index a4ef872..fbd65ef 100644 --- a/README.md +++ b/README.md @@ -1,20 +1,24 @@ +# TonAPI SDK -# Description +## Description This repository contains [TonAPI](https://tonapi.io) SDK and examples. -The native TON's RPC is very low-level. -And it is not suitable for building applications on top of it. +The native TON's RPC is very low-level and is not suitable for building applications on top of it. [TonAPI](https://tonapi.io) aims at speeding up development of TON-based applications and provides an API centered around high-level concepts like Jettons, NFTs and so on, while keeping a way to access low-level details. -[TonAPI](https://tonapi.io) aims at speeding up development of TON-based applications and -provides an API centered around high-level concepts like Jettons, NFTs and so on, -keeping a way to access low-level details. +Check out more details at [TonAPI Documentation](https://docs.tonconsole.com/tonapi/rest-api). -Check out more details at [TonAPI Documentation](https://docs.tonconsole.com/tonapi/api-v2). +## Installation -# TonAPI SDK Example +To install the TonAPI SDK, run: -Development of TON-based applications is much easier with TonAPI SDK: +```bash +go get github.com/tonkeeper/tonapi-go +``` + +## Quick Start + +Here's a simple example to get you started: ```go package main @@ -28,36 +32,171 @@ import ( ) func main() { - client, err := tonapi.New() + // Create a new client with default settings + // If you want to use testnet, use tonapi.TestnetTonApiURL + // You can use TonAPI.io without a token by passing &tonapi.Security{} as the second parameter, + // but note that TonAPI.io has strict rate limits, so it's better to get a Token from tonconsole.com + // in the TonAPI section - it's completely free + client, err := tonapi.NewClient(tonapi.TonApiURL, &tonapi.Security{}) if err != nil { log.Fatal(err) } - account, err := client.GetAccount(context.Background(), tonapi.GetAccountParams{AccountID: "EQBszTJahYw3lpP64ryqscKQaDGk4QpsO7RO6LYVvKHSINS0"}) + + // Get account information + account, err := client.GetAccount(context.Background(), tonapi.GetAccountParams{ + AccountID: "EQBszTJahYw3lpP64ryqscKQaDGk4QpsO7RO6LYVvKHSINS0", + }) if err != nil { log.Fatal(err) } - fmt.Printf("Account: %v\n", account.Balance) + + fmt.Printf("Account Balance: %v\n", account.Balance) } ``` -Take a look at [TonAPI SDK examples](examples). +## Configuration Options + +### Network Selection + +You can specify which network to use: + +```go +// For mainnet +client, err := tonapi.NewClient(tonapi.TonApiURL, &tonapi.Security{}) + +// For testnet +client, err := tonapi.NewClient(tonapi.TestnetTonApiURL, &tonapi.Security{}) +``` + +### Authentication + +While TonAPI can be used without authentication, it's recommended to obtain an API token to avoid rate limits: + +```go +// Using API token (recommended) +token := "your-api-token" // Get your free token from tonconsole.com +client, err := tonapi.NewClient(tonapi.TonApiURL, tonapi.WithToken(token)) +``` + +You can get your free API token from [TON Console](https://tonconsole.com/tonapi/api-keys) in the TonAPI section. -## Rest API +### Custom HTTP Client -You can always find the latest version of TonAPI Rest API documentation at [TonAPI Documentation](https://docs.tonconsole.com/tonapi/api-v2). +You can also use a custom client by using WithClient, where you can, for example, pass a throttled client: -[TonAPI SDK example](examples/tonapi-sdk/main.go) shows how to work with Rest API in golang. +```go +import ( + "net/http" + "time" + + "github.com/tonkeeper/tonapi-go" + "golang.org/x/time/rate" +) + +func main() { + // Create a throttled client + throttledClient := &http.Client{ + Transport: throttled.NewTransport( + http.DefaultTransport, + rate.NewLimiter(1, 1)), // Set values according to the rate plan of the token + } + + // Use custom client with token + token := "your-api-token" + client, err := tonapi.NewClient( + tonapi.TonApiURL, + tonapi.WithToken(token), + tonapi.WithClient(throttledClient), + ) + if err != nil { + // handle error + } + + // Use client... +} +``` + +## Common Operations + +### Get Account Information + +```go +account, err := client.GetAccount(context.Background(), tonapi.GetAccountParams{ + AccountID: "EQBszTJahYw3lpP64ryqscKQaDGk4QpsO7RO6LYVvKHSINS0", +}) +``` + +### Get Transactions + +```go +transactions, err := client.GetTransactions(context.Background(), tonapi.GetTransactionsParams{ + AccountID: "EQBszTJahYw3lpP64ryqscKQaDGk4QpsO7RO6LYVvKHSINS0", + Limit: 10, +}) +``` + +### Get Jettons + +```go +jettons, err := client.GetAccountJettons(context.Background(), tonapi.GetAccountJettonsParams{ + AccountID: "EQBszTJahYw3lpP64ryqscKQaDGk4QpsO7RO6LYVvKHSINS0", +}) +``` + +## Error Handling + +Always check for errors when making API calls: + +```go +result, err := client.GetAccount(context.Background(), params) +if err != nil { + // Check if it's a TonAPI error + if apiErr, ok := err.(*tonapi.Error); ok { + fmt.Printf("API Error: %v\n", apiErr.Error) + } else { + fmt.Printf("Error: %s\n", err.Error()) + } + return +} +``` + +## Rate Limiting + +TonAPI has rate limits based on your authentication: +- Anonymous users: Strict rate limits +- API token users: Higher limits based on your plan + +For high-volume applications, consider implementing a throttled client as shown in the examples. + +## Best Practices + +1. Always use an API token for production applications +2. Implement proper error handling for all API calls +3. Use a custom HTTP client with rate limiting for high-volume applications +4. Consider caching frequently accessed data + +## Documentation + +For complete API documentation, visit the [Documentation](https://docs.tonconsole.com) website. + +## Support + +For support and questions, join the [TonApi Tech](https://t.me/tonapitech) on Telegram. + +## REST API + +You can always find the latest version of TonAPI REST API documentation at [TonAPI Documentation](https://docs.tonconsole.com/tonapi/rest-api). + +[TonAPI SDK example](examples/tonapi-sdk/main.go) shows how to work with REST API in golang. ## Streaming API Usually, an application needs to monitor the blockchain for specific events and act accordingly. TonAPI offers two ways to do it: SSE and Websocket. -The advantage of Websocket is that Websocket can be reconfigured dynamically to subscribe/unsubscribe to/from specific events. -Where SSE has to reconnect to TonAPI to change the list of events it is subscribed to. +The advantage of Websocket is that it can be reconfigured dynamically to subscribe/unsubscribe to/from specific events, +whereas SSE has to reconnect to TonAPI to change the list of events it is subscribed to. Take a look at [SSE example](examples/sse/main.go) and [Websocket example](examples/websocket/main.go) to see how to work with TonAPI Streaming API in golang. -More details can be found at [TonAPI Streaming API Documentation](https://docs.tonconsole.com/tonapi/streaming-api). - - +More details can be found at [TonAPI Streaming API Documentation](https://docs.tonconsole.com/tonapi/streaming-api). \ No newline at end of file diff --git a/api/openapi.yml b/api/openapi.yml index af660c7..99b06e2 100644 --- a/api/openapi.yml +++ b/api/openapi.yml @@ -1,4 +1,4 @@ -openapi: 3.0.2 +openapi: 3.0.0 info: title: REST api to TON blockchain explorer version: 2.0.0 @@ -10,13 +10,123 @@ servers: - url: "https://tonapi.io" - url: "https://testnet.tonapi.io" - url: "http://localhost:8081" + +tags: + - name: Accounts + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/accounts + - name: NFT + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/nft + - name: Jettons + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/jettons + - name: DNS + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/dns + - name: Wallet + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/wallet + - name: Rates + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/rates + - name: Staking + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/staking + - name: Traces + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/traces + - name: Events + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/events + - name: Storage + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/storage + - name: Connect + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/connect + - name: Gasless + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/gasless + - name: Multisig + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/multisig + - name: Blockchain + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/blockchain + - name: Lite Server + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/lite-server + - name: Emulation + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/emulation + - name: Utilities + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/utilities + - name: ExtraCurrency + externalDocs: + description: Additional documentation + url: https://docs.tonconsole.com/tonapi/rest-api/extra-currency + - name: Purchases + +security: + - bearerAuth: [ ] + - { } + paths: + /v2/openapi.json: + get: + description: Get the openapi.json file + operationId: getOpenapiJson + tags: + - Utilities + responses: + '200': + description: openapi.json + content: + application/json: + schema: { } # Free-form JSON value + 'default': + $ref: '#/components/responses/Error' + /v2/openapi.yml: + get: + description: Get the openapi.yml file + operationId: getOpenapiYml + tags: + - Utilities + responses: + '200': + description: openapi.yml + content: + application/yaml: + schema: + type: string + format: binary + 'default': + $ref: '#/components/responses/Error' /v2/status: get: description: Status operationId: status tags: - - Blockchain + - Utilities responses: '200': description: status @@ -61,6 +171,29 @@ paths: $ref: '#/components/schemas/BlockchainBlock' 'default': $ref: '#/components/responses/Error' + /v2/blockchain/blocks/{block_id}/boc: + get: + description: Download blockchain block BOC + operationId: downloadBlockchainBlockBoc + tags: + - Blockchain + parameters: + - $ref: '#/components/parameters/blockchainBlockIDParameter' + responses: + '200': + description: Block BOC file + content: + application/octet-stream: + schema: + type: string + format: binary + headers: + Content-Disposition: + schema: + type: string + example: 'attachment; filename="block.boc"' + 'default': + $ref: '#/components/responses/Error' /v2/blockchain/masterchain/{masterchain_seqno}/shards: get: description: Get blockchain block shards @@ -310,14 +443,14 @@ paths: schema: type: array description: |- - Supported values: - "NaN" for NaN type, - "Null" for Null type, - 10-base digits for tiny int type (Example: 100500), - 0x-prefixed hex digits for int257 (Example: 0xfa01d78381ae32), - all forms of addresses for slice type (Example: 0:6e731f2e28b73539a7f85ac47ca104d5840b229351189977bb6151d36b5e3f5e), - single-root base64-encoded BOC for cell (Example: "te6ccgEBAQEAAgAAAA=="), - single-root hex-encoded BOC for slice (Example: b5ee9c72010101010002000000) + Array of method arguments in string format. Supported value formats: + - "NaN" for Not-a-Number type + - "Null" for Null type + - Decimal integers for tinyint type (e.g., "100500") + - 0x-prefixed hex strings for int257 type (e.g., "0xfa01d78381ae32") + - TON blockchain addresses for slice type (e.g., "0:6e731f2e28b73539a7f85ac47ca104d5840b229351189977bb6151d36b5e3f5e") + - Base64-encoded BOC for cell type (e.g., "te6ccgEBAQEAAgAAAA==") + - Hex-encoded BOC for slice type (e.g., "b5ee9c72010101010002000000") items: type: string example: [ "0:9a33970f617bcd71acf2cd28357c067aa31859c02820d8f01d74c88063a8f4d8" ] @@ -330,6 +463,25 @@ paths: $ref: '#/components/schemas/MethodExecutionResult' 'default': $ref: '#/components/responses/Error' + post: + description: Execute get method for account + operationId: execGetMethodWithBodyForBlockchainAccount + tags: + - Blockchain + parameters: + - $ref: '#/components/parameters/accountIDParameter' + - $ref: '#/components/parameters/methodNameParameter' + requestBody: + $ref: "#/components/requestBodies/ExecGetMethodArgs" + responses: + '200': + description: method execution result + content: + application/json: + schema: + $ref: '#/components/schemas/MethodExecutionResult' + 'default': + $ref: '#/components/responses/Error' /v2/blockchain/message: post: description: Send message to blockchain @@ -390,21 +542,21 @@ 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 + /v2/blockchain/libraries/{hash}: + get: + description: Get library cell + operationId: getLibraryByHash tags: - - Emulation - requestBody: - $ref: "#/components/requestBodies/Boc" + - Blockchain + parameters: + - $ref: '#/components/parameters/hashParameter' responses: '200': - description: decoded message + description: library cell content: application/json: schema: - $ref: '#/components/schemas/DecodedMessage' + $ref: '#/components/schemas/BlockchainLibrary' 'default': $ref: '#/components/responses/Error' /v2/address/{account_id}/parse: @@ -412,7 +564,7 @@ paths: description: parse address and display in all formats operationId: addressParse tags: - - Accounts + - Utilities parameters: - $ref: '#/components/parameters/accountIDParameter' responses: @@ -459,99 +611,6 @@ paths: type: boolean default: $ref: '#/components/responses/Error' - - /v2/events/emulate: - post: - description: Emulate sending message to blockchain - operationId: emulateMessageToEvent - tags: - - Emulation - parameters: - - $ref: '#/components/parameters/i18n' - - name: ignore_signature_check - in: query - required: false - schema: - type: boolean - requestBody: - $ref: "#/components/requestBodies/Boc" - responses: - '200': - description: emulated event - content: - application/json: - schema: - $ref: '#/components/schemas/Event' - 'default': - $ref: '#/components/responses/Error' - /v2/traces/emulate: - post: - description: Emulate sending message to blockchain - operationId: emulateMessageToTrace - tags: - - Emulation - parameters: - - name: ignore_signature_check - in: query - required: false - schema: - type: boolean - requestBody: - $ref: "#/components/requestBodies/Boc" - responses: - '200': - description: emulated trace - content: - application/json: - schema: - $ref: '#/components/schemas/Trace' - 'default': - $ref: '#/components/responses/Error' - /v2/wallet/emulate: - post: - description: Emulate sending message to blockchain - operationId: emulateMessageToWallet - tags: - - Emulation - parameters: - - $ref: '#/components/parameters/i18n' - requestBody: - $ref: "#/components/requestBodies/EmulationBoc" - responses: - '200': - description: emulated message - content: - application/json: - schema: - $ref: '#/components/schemas/MessageConsequences' - 'default': - $ref: '#/components/responses/Error' - /v2/accounts/{account_id}/events/emulate: - post: - description: Emulate sending message to blockchain - operationId: emulateMessageToAccountEvent - tags: - - Emulation - parameters: - - $ref: '#/components/parameters/i18n' - - $ref: '#/components/parameters/accountIDParameter' - - name: ignore_signature_check - in: query - required: false - schema: - type: boolean - requestBody: - $ref: "#/components/requestBodies/Boc" - responses: - '200': - description: emulated message to account - content: - application/json: - schema: - $ref: '#/components/schemas/AccountEvent' - 'default': - $ref: '#/components/responses/Error' - /v2/accounts/_bulk: post: description: Get human-friendly information about several accounts without low-level details. @@ -634,6 +693,7 @@ paths: - $ref: '#/components/parameters/accountIDParameter' - $ref: '#/components/parameters/jettonIDParameter' - $ref: '#/components/parameters/currenciesQuery' + - $ref: '#/components/parameters/supportedExtensions' responses: '200': description: account jetton balance @@ -651,7 +711,6 @@ paths: - Accounts parameters: - $ref: '#/components/parameters/accountIDParameter' - - $ref: '#/components/parameters/i18n' - name: before_lt in: query description: "omit this parameter to get last events" @@ -669,32 +728,19 @@ paths: example: 100 maximum: 1000 minimum: 1 - - name: start_date - in: query - required: false - schema: - type: integer - format: int64 - example: 1668436763 - - name: end_date - in: query - required: false - schema: - type: integer - format: int64 - example: 1668436763 responses: '200': description: account jettons history content: application/json: schema: - $ref: '#/components/schemas/AccountEvents' + $ref: '#/components/schemas/JettonOperations' 'default': $ref: '#/components/responses/Error' /v2/accounts/{account_id}/jettons/{jetton_id}/history: get: - description: Get the transfer jetton history for account and jetton + deprecated: true + description: Please use `getJettonAccountHistoryByID`` instead operationId: getAccountJettonHistoryByID tags: - Accounts @@ -725,6 +771,7 @@ paths: schema: type: integer format: int64 + maximum: 2114380800 example: 1668436763 - name: end_date in: query @@ -732,6 +779,7 @@ paths: schema: type: integer format: int64 + maximum: 2114380800 example: 1668436763 responses: '200': @@ -795,27 +843,13 @@ paths: example: 100 maximum: 1000 minimum: 1 - - name: start_date - in: query - required: false - schema: - type: integer - format: int64 - example: 1668436763 - - name: end_date - in: query - required: false - schema: - type: integer - format: int64 - example: 1668436763 responses: '200': description: nft history content: application/json: schema: - $ref: '#/components/schemas/AccountEvents' + $ref: '#/components/schemas/NftOperations' 'default': $ref: '#/components/responses/Error' /v2/accounts/{account_id}/events: @@ -858,6 +892,7 @@ paths: schema: type: integer format: int64 + maximum: 2114380800 example: 1668436763 - name: end_date in: query @@ -865,6 +900,7 @@ paths: schema: type: integer format: int64 + maximum: 2114380800 example: 1668436763 responses: '200': @@ -1061,6 +1097,7 @@ paths: schema: type: integer format: int64 + maximum: 2114380800 example: 1668436763 - name: end_date in: query @@ -1068,6 +1105,7 @@ paths: schema: type: integer format: int64 + maximum: 2114380800 example: 1668436763 responses: '200': @@ -1086,6 +1124,59 @@ paths: 'default': $ref: '#/components/responses/Error' + /v2/accounts/{account_id}/extra-currency/{id}/history: + get: + description: Get the transfer history of extra currencies for an account. + operationId: getAccountExtraCurrencyHistoryByID + tags: + - Accounts + parameters: + - $ref: '#/components/parameters/accountIDParameter' + - $ref: '#/components/parameters/ecIDParameter' + - $ref: '#/components/parameters/i18n' + - name: before_lt + in: query + description: "omit this parameter to get last events" + required: false + schema: + type: integer + format: int64 + example: 25758317000002 + x-js-format: bigint + - name: limit + in: query + required: true + schema: + type: integer + example: 100 + maximum: 1000 + minimum: 1 + - name: start_date + in: query + required: false + schema: + type: integer + format: int64 + maximum: 2114380800 + example: 1668436763 + - name: end_date + in: query + required: false + schema: + type: integer + format: int64 + maximum: 2114380800 + example: 1668436763 + responses: + '200': + description: account extra currency history + content: + application/json: + schema: + $ref: '#/components/schemas/AccountEvents' + 'default': + $ref: '#/components/responses/Error' + /v2/dns/{domain_name}: get: description: Get full information about domain name @@ -1111,6 +1202,12 @@ paths: - DNS parameters: - $ref: '#/components/parameters/domainNameParameter' + - name: filter + in: query + schema: + type: boolean + default: false + required: false responses: '200': description: dns record @@ -1205,6 +1302,23 @@ paths: $ref: '#/components/schemas/NftCollection' 'default': $ref: '#/components/responses/Error' + /v2/nfts/collections/_bulk: + post: + description: Get NFT collection items by their addresses + operationId: getNftCollectionItemsByAddresses + tags: + - NFT + requestBody: + $ref: "#/components/requestBodies/AccountIDs" + responses: + '200': + description: nft collections + content: + application/json: + schema: + $ref: '#/components/schemas/NftCollections' + 'default': + $ref: '#/components/responses/Error' /v2/nfts/collections/{account_id}/items: get: description: Get NFT items from collection by collection address @@ -1260,7 +1374,8 @@ paths: $ref: '#/components/responses/Error' /v2/nfts/{account_id}/history: get: - description: Get the transfer nfts history for account + deprecated: true + description: Please use `getAccountNftHistory`` instead operationId: getNftHistoryByID tags: - NFT @@ -1290,6 +1405,7 @@ paths: schema: type: integer format: int64 + maximum: 2114380800 example: 1668436763 - name: end_date in: query @@ -1297,6 +1413,7 @@ paths: schema: type: integer format: int64 + maximum: 2114380800 example: 1668436763 responses: '200': @@ -1344,177 +1461,12 @@ paths: 'default': $ref: '#/components/responses/Error' - /v2/experimental/accounts/{account_id}/inscriptions: + /v2/jettons: get: - description: Get all inscriptions by owner address. It's experimental API and can be dropped in the future. - operationId: getAccountInscriptions + description: Get a list of all indexed jetton masters in the blockchain. + operationId: getJettons tags: - - Inscriptions - parameters: - - $ref: '#/components/parameters/accountIDParameter' - - $ref: '#/components/parameters/limitQuery' - - $ref: '#/components/parameters/offsetQuery' - responses: - '200': - description: account inscriptions - content: - application/json: - schema: - $ref: '#/components/schemas/InscriptionBalances' - 'default': - $ref: '#/components/responses/Error' - /v2/experimental/accounts/{account_id}/inscriptions/history: - get: - description: Get the transfer inscriptions history for account. It's experimental API and can be dropped in the future. - operationId: getAccountInscriptionsHistory - tags: - - Inscriptions - parameters: - - $ref: '#/components/parameters/accountIDParameter' - - $ref: '#/components/parameters/i18n' - - name: before_lt - in: query - description: "omit this parameter to get last events" - required: false - schema: - type: integer - format: int64 - example: 25758317000002 - x-js-format: bigint - - name: limit - in: query - required: false - schema: - type: integer - example: 100 - default: 100 - maximum: 1000 - minimum: 1 - responses: - '200': - description: account inscriptions history - content: - application/json: - schema: - $ref: '#/components/schemas/AccountEvents' - 'default': - $ref: '#/components/responses/Error' - /v2/experimental/accounts/{account_id}/inscriptions/{ticker}/history: - get: - description: Get the transfer inscriptions history for account. It's experimental API and can be dropped in the future. - operationId: getAccountInscriptionsHistoryByTicker - tags: - - Inscriptions - parameters: - - $ref: '#/components/parameters/accountIDParameter' - - $ref: '#/components/parameters/i18n' - - name: ticker - in: path - required: true - schema: - type: string - example: "nano" - - name: before_lt - in: query - description: "omit this parameter to get last events" - required: false - schema: - type: integer - format: int64 - example: 25758317000002 - x-js-format: bigint - - name: limit - in: query - required: false - schema: - type: integer - example: 100 - default: 100 - maximum: 1000 - minimum: 1 - responses: - '200': - description: account inscriptions history - content: - application/json: - schema: - $ref: '#/components/schemas/AccountEvents' - 'default': - $ref: '#/components/responses/Error' - /v2/experimental/inscriptions/op-template: - get: - description: return comment for making operation with inscription. please don't use it if you don't know what you are doing - operationId: getInscriptionOpTemplate - tags: - - Inscriptions - parameters: - - in: query - name: type - required: true - schema: - type: string - enum: [ "ton20", "gram20" ] - example: "ton20" - - in: query - name: destination - required: false - schema: - type: string - - in: query - name: comment - required: false - schema: - type: string - - in: query - name: operation - required: true - schema: - type: string - enum: [ "transfer" ] - example: "transfer" - - in: query - name: amount - required: true - schema: - type: string - example: "1000000000" - - in: query - name: ticker - required: true - schema: - type: string - example: "nano" - - in: query - name: who - required: true - schema: - type: string - example: UQAs87W4yJHlF8mt29ocA4agnMrLsOP69jC1HPyBUjJay7Mg - responses: - '200': - description: inscription op template - content: - application/json: - schema: - type: object - required: - - comment - - destination - properties: - comment: - type: string - example: "comment" - destination: - type: string - example: "0:0000000000000" - 'default': - $ref: '#/components/responses/Error' - /v2/jettons: - get: - description: Get a list of all indexed jetton masters in the blockchain. - operationId: getJettons - tags: - - Jettons + - Jettons parameters: - name: limit in: query @@ -1559,6 +1511,23 @@ paths: $ref: '#/components/schemas/JettonInfo' 'default': $ref: '#/components/responses/Error' + /v2/jettons/_bulk: + post: + description: Get jetton metadata items by jetton master addresses + operationId: getJettonInfosByAddresses + tags: + - Jettons + requestBody: + $ref: "#/components/requestBodies/AccountIDs" + responses: + '200': + description: a list of jettons + content: + application/json: + schema: + $ref: '#/components/schemas/Jettons' + 'default': + $ref: '#/components/responses/Error' /v2/jettons/{account_id}/holders: get: description: Get jetton's holders @@ -1568,7 +1537,14 @@ paths: parameters: - $ref: '#/components/parameters/accountIDParameter' - $ref: '#/components/parameters/limitQuery' - - $ref: '#/components/parameters/offsetQuery' + - in: query + name: offset + required: false + schema: + type: integer + default: 0 + minimum: 0 + maximum: 9000 responses: '200': description: jetton's holders @@ -1614,6 +1590,75 @@ paths: $ref: '#/components/schemas/Event' 'default': $ref: '#/components/responses/Error' + /v2/jettons/{jetton_id}/accounts/{account_id}/history: + get: + description: Get the transfer jetton history for account and jetton + operationId: getJettonAccountHistoryByID + tags: + - Accounts + parameters: + - $ref: '#/components/parameters/accountIDParameter' + - $ref: '#/components/parameters/jettonIDParameter' + - name: before_lt + in: query + description: "omit this parameter to get last events" + required: false + schema: + type: integer + format: int64 + example: 25758317000002 + x-js-format: bigint + - name: limit + in: query + required: true + schema: + type: integer + example: 100 + maximum: 1000 + minimum: 1 + - name: start_date + in: query + required: false + schema: + type: integer + format: int64 + maximum: 2114380800 + example: 1668436763 + - name: end_date + in: query + required: false + schema: + type: integer + format: int64 + maximum: 2114380800 + example: 1668436763 + responses: + '200': + description: account jetton history + content: + application/json: + schema: + $ref: '#/components/schemas/JettonOperations' + 'default': + $ref: '#/components/responses/Error' + + /v2/extra-currency/{id}: + get: + description: Get extra currency info by id + operationId: getExtraCurrencyInfo + tags: + - ExtraCurrency + parameters: + - $ref: '#/components/parameters/ecIDParameter' + responses: + '200': + description: extra currency info + content: + application/json: + schema: + $ref: '#/components/schemas/EcPreview' + 'default': + $ref: '#/components/responses/Error' /v2/staking/nominator/{account_id}/pools: get: @@ -1808,6 +1853,7 @@ paths: required: true schema: type: string + format: address - in: query name: currency required: false @@ -1820,6 +1866,7 @@ paths: schema: type: integer format: int64 + maximum: 2114380800 example: 1668436763 - name: end_date in: query @@ -1827,6 +1874,7 @@ paths: schema: type: integer format: int64 + maximum: 2114380800 example: 1668436763 - name: points_count in: query @@ -1848,8 +1896,7 @@ paths: - points properties: points: - additionalProperties: true - example: { } + $ref: '#/components/schemas/ChartPoints' 'default': $ref: '#/components/responses/Error' /v2/rates/markets: @@ -1913,77 +1960,66 @@ paths: $ref: '#/components/schemas/AccountInfoByStateInit' 'default': $ref: '#/components/responses/Error' - - /v2/wallet/backup: - get: - description: Get backup info - operationId: getWalletBackup + /v2/wallet/auth/proof: + post: + description: Account verification and token issuance + operationId: tonConnectProof tags: - Wallet - parameters: - - in: header - name: X-TonConnect-Auth - schema: - type: string - required: true + requestBody: + $ref: "#/components/requestBodies/TonConnectProof" responses: '200': - description: get wallet dump + description: auth token content: application/json: schema: type: object required: - - dump + - token properties: - dump: + token: type: string + example: "NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2ODQ3..." 'default': $ref: '#/components/responses/Error' - put: - description: Set backup info - operationId: setWalletBackup + /v2/wallet/{account_id}/seqno: + get: + description: Get account seqno + operationId: getAccountSeqno tags: - Wallet parameters: - - in: header - name: X-TonConnect-Auth - schema: - type: string - required: true - requestBody: - $ref: "#/components/requestBodies/Backup" + - $ref: '#/components/parameters/accountIDParameter' responses: '200': - description: success + description: account seqno + content: + application/json: + schema: + $ref: '#/components/schemas/Seqno' 'default': $ref: '#/components/responses/Error' - /v2/wallet/auth/proof: - post: - description: Account verification and token issuance - operationId: tonConnectProof + /v2/wallet/{account_id}: + get: + description: Get human-friendly information about a wallet without low-level details. + operationId: getWalletInfo tags: - Wallet - requestBody: - $ref: "#/components/requestBodies/TonConnectProof" + parameters: + - $ref: '#/components/parameters/accountIDParameter' responses: '200': - description: auth token + description: wallet content: application/json: schema: - type: object - required: - - token - properties: - token: - type: string - example: "NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2ODQ3..." + $ref: '#/components/schemas/Wallet' 'default': $ref: '#/components/responses/Error' /v2/gasless/config: get: - description: "Returns configuration of gasless transfers" + description: Returns configuration of gasless transfers operationId: gaslessConfig tags: - Gasless @@ -1998,9 +2034,10 @@ paths: $ref: '#/components/responses/Error' /v2/gasless/estimate/{master_id}: post: - description: "Estimates the cost of the given messages and returns a payload to sign." + description: Estimates the cost of the given messages and returns a payload to sign operationId: gaslessEstimate parameters: + - $ref: '#/components/parameters/i18n' - name: master_id in: path required: true @@ -2024,6 +2061,7 @@ paths: $ref: '#/components/responses/Error' /v2/gasless/send: post: + description: Submits the signed gasless transaction message to the network operationId: gaslessSend tags: - Gasless @@ -2032,6 +2070,10 @@ paths: responses: '200': description: the message has been sent + content: + application/json: + schema: + $ref: '#/components/schemas/GaslessTx' 'default': $ref: '#/components/responses/Error' /v2/pubkeys/{public_key}/wallets: @@ -2048,24 +2090,7 @@ paths: content: application/json: schema: - $ref: '#/components/schemas/Accounts' - 'default': - $ref: '#/components/responses/Error' - /v2/wallet/{account_id}/seqno: - get: - description: Get account seqno - operationId: getAccountSeqno - tags: - - Wallet - parameters: - - $ref: '#/components/parameters/accountIDParameter' - responses: - '200': - description: account seqno - content: - application/json: - schema: - $ref: '#/components/schemas/Seqno' + $ref: '#/components/schemas/Wallets' 'default': $ref: '#/components/responses/Error' @@ -2646,87 +2671,257 @@ paths: - $ref: '#/components/parameters/blockchainBlockIDExtParameter' responses: '200': - description: raw shard block proof + description: raw shard block proof + content: + application/json: + schema: + type: object + required: + - masterchain_id + - links + properties: + masterchain_id: + $ref: '#/components/schemas/BlockRaw' + links: + type: array + items: + type: object + required: + - id + - proof + properties: + id: + $ref: '#/components/schemas/BlockRaw' + proof: + type: string + example: 131D0C65055F04E9C19D687B51BC70F952FD9CA6F02C2801D3B89964A779DF85 + 'default': + $ref: '#/components/responses/Error' + /v2/liteserver/get_out_msg_queue_sizes: + get: + description: Get out msg queue sizes + operationId: getOutMsgQueueSizes + tags: + - Lite Server + responses: + '200': + description: out msg queue sizes + content: + application/json: + schema: + type: object + required: + - ext_msg_queue_size_limit + - shards + properties: + ext_msg_queue_size_limit: + type: integer + format: uint32 + shards: + type: array + items: + type: object + required: + - id + - size + properties: + id: + $ref: '#/components/schemas/BlockRaw' + size: + type: integer + format: uint32 + 'default': + $ref: '#/components/responses/Error' + + /v2/multisig/{account_id}: + get: + description: Get multisig account info + operationId: getMultisigAccount + tags: + - Multisig + parameters: + - $ref: '#/components/parameters/accountIDParameter' + responses: + '200': + description: multisig account + content: + application/json: + schema: + $ref: '#/components/schemas/Multisig' + 'default': + $ref: '#/components/responses/Error' + + /v2/multisig/order/{account_id}: + get: + description: Get multisig order + operationId: getMultisigOrder + tags: + - Multisig + parameters: + - $ref: '#/components/parameters/accountIDParameter' + responses: + '200': + description: multisig order + content: + application/json: + schema: + $ref: '#/components/schemas/MultisigOrder' + '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/events/emulate: + post: + description: Emulate sending message to retrieve general blockchain events + operationId: emulateMessageToEvent + tags: + - Emulation + - Events + parameters: + - $ref: '#/components/parameters/i18n' + - name: ignore_signature_check + in: query + required: false + schema: + type: boolean + requestBody: + $ref: "#/components/requestBodies/Boc" + responses: + '200': + description: emulated event + content: + application/json: + schema: + $ref: '#/components/schemas/Event' + 'default': + $ref: '#/components/responses/Error' + /v2/traces/emulate: + post: + description: Emulate sending message to retrieve with a detailed execution trace + operationId: emulateMessageToTrace + tags: + - Emulation + - Traces + parameters: + - name: ignore_signature_check + in: query + required: false + schema: + type: boolean + requestBody: + $ref: "#/components/requestBodies/Boc" + responses: + '200': + description: emulated trace + content: + application/json: + schema: + $ref: '#/components/schemas/Trace' + 'default': + $ref: '#/components/responses/Error' + /v2/wallet/emulate: + post: + description: Emulate sending message to retrieve the resulting wallet state + operationId: emulateMessageToWallet + tags: + - Emulation + - Wallet + parameters: + - $ref: '#/components/parameters/i18n' + - $ref: '#/components/parameters/currencyQuery' + requestBody: + $ref: "#/components/requestBodies/EmulationBoc" + responses: + '200': + description: emulated message content: application/json: schema: - type: object - required: - - masterchain_id - - links - properties: - masterchain_id: - $ref: '#/components/schemas/BlockRaw' - links: - type: array - items: - type: object - required: - - id - - proof - properties: - id: - $ref: '#/components/schemas/BlockRaw' - proof: - type: string - example: 131D0C65055F04E9C19D687B51BC70F952FD9CA6F02C2801D3B89964A779DF85 + $ref: '#/components/schemas/MessageConsequences' 'default': $ref: '#/components/responses/Error' - /v2/liteserver/get_out_msg_queue_sizes: - get: - description: Get out msg queue sizes - operationId: getOutMsgQueueSizes + /v2/accounts/{account_id}/events/emulate: + post: + description: Emulate sending message to retrieve account-specific events + operationId: emulateMessageToAccountEvent tags: - - Lite Server + - Emulation + - Accounts + parameters: + - $ref: '#/components/parameters/i18n' + - $ref: '#/components/parameters/accountIDParameter' + - name: ignore_signature_check + in: query + required: false + schema: + type: boolean + requestBody: + $ref: "#/components/requestBodies/Boc" responses: '200': - description: out msg queue sizes + description: emulated message to account content: application/json: schema: - type: object - required: - - ext_msg_queue_size_limit - - shards - properties: - ext_msg_queue_size_limit: - type: integer - format: uint32 - shards: - type: array - items: - type: object - required: - - id - - size - properties: - id: - $ref: '#/components/schemas/BlockRaw' - size: - type: integer - format: uint32 + $ref: '#/components/schemas/AccountEvent' 'default': $ref: '#/components/responses/Error' - - /v2/multisig/{account_id}: + /v2/purchases/{account_id}/history: get: - description: Get multisig account info - operationId: getMultisigAccount + description: Get history of purchases + operationId: getPurchaseHistory tags: - - Multisig + - Purchases parameters: - $ref: '#/components/parameters/accountIDParameter' + - name: before_lt + in: query + description: "omit this parameter to get last invoices" + required: false + schema: + type: integer + format: int64 + example: 25758317000002 + x-js-format: bigint + - name: limit + in: query + required: false + schema: + type: integer + default: 100 + example: 100 + maximum: 1000 + minimum: 1 responses: '200': - description: multisig account + description: account purchase history content: application/json: schema: - $ref: '#/components/schemas/Multisig' + $ref: '#/components/schemas/AccountPurchases' 'default': $ref: '#/components/responses/Error' - components: + securitySchemes: + bearerAuth: + type: http + scheme: bearer parameters: masterchainSeqno: in: path @@ -2831,6 +3026,15 @@ components: schema: type: string example: 97264395BD65A255A429B11326C84128B7D70FFED7949ABAE3036D506BA38621 + ecIDParameter: + in: path + name: id + required: true + description: "extra currency id" + schema: + type: integer + example: 239 + format: int32 publicKeyParameter: in: path name: public_key @@ -2838,6 +3042,14 @@ components: schema: type: string example: NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE2ODQ3... + hashParameter: + in: path + name: hash + required: true + description: "hash in hex (without 0x) format" + schema: + type: string + example: "131D0C65055F04E9C19D687B51BC70F952FD9CA6F02C2801D3B89964A779DF85" i18n: in: header name: Accept-Language @@ -3013,7 +3225,7 @@ components: type: array items: type: string - example: ["custom_payload"] + example: [ "custom_payload" ] currencyQuery: in: query name: currency @@ -3056,10 +3268,14 @@ components: format: cell batch: type: array - maxItems: 10 + maxItems: 5 items: type: string format: cell + meta: + type: object + additionalProperties: + type: string EmulationBoc: description: bag-of-cells serialized to base64/hex and additional parameters to configure emulation required: true @@ -3102,6 +3318,13 @@ components: - wallet_address - wallet_public_key properties: + throw_error_if_not_enough_jettons: + type: boolean + default: false + description: TONAPI verifies that the account has enough jettons to pay the commission and make a transfer. + return_emulation: + type: boolean + default: false wallet_address: type: string format: address @@ -3207,14 +3430,6 @@ components: state_init: type: string format: cell-base64 - Backup: - description: "Information for saving backup" - required: true - content: - application/octet-stream: - schema: - type: string - format: binary TonConnectStateInit: description: "Data that is expected" required: true @@ -3241,7 +3456,22 @@ components: body: type: string format: cell-base64 - + ExecGetMethodArgs: + description: > + Request body for executing a GET method on a blockchain account via POST. + This format allows passing arguments in the request body instead of query parameters, + which is especially useful for large or complex input data. + content: + application/json: + schema: + type: object + required: + - args + properties: + args: + type: array + items: + $ref: '#/components/schemas/ExecGetMethodArg' schemas: Error: type: object @@ -3301,6 +3531,7 @@ components: example: 13 value: type: string + x-js-format: bigint example: "10000000000" BlockValueFlow: type: object @@ -3369,7 +3600,8 @@ components: format: int32 shard: type: string - example: 8000000000000000 + # x-js-format: bigint ??? + example: "8000000000000000" seqno: type: integer example: 21734019 @@ -3388,12 +3620,12 @@ components: type: array items: type: string - example: [ (0,4234235,8000000000000000) ] + example: "[ (0,4234235,8000000000000000) ]" parent: type: array items: type: string - example: [ (0,21734018,8000000000000000) ] + example: "[ (0,21734018,8000000000000000) ]" BlockchainBlock: type: object required: @@ -3436,7 +3668,8 @@ components: format: int32 shard: type: string - example: 8000000000000000 + # x-js-format: bigint ??? + example: "8000000000000000" seqno: type: integer example: 21734019 @@ -3588,9 +3821,9 @@ components: format: cell example: b5ee9c72010106010044000114ff00f4a413f4bcf2c80b01020120020302014804050004f2300038d06c21d31f30ed44d0d33f3001c00197a4c8cb3fc9ed549330f206e20011a13431da89a1a67e61 interfaces: - type: array - items: - type: string + type: array + items: + type: string Message: type: object required: @@ -3632,6 +3865,10 @@ components: format: int64 x-js-format: bigint example: 60000000 + value_extra: + type: array + items: + $ref: '#/components/schemas/ExtraCurrency' fwd_fee: type: integer format: int64 @@ -3657,6 +3894,7 @@ components: example: 5681002 op_code: type: string + x-js-format: bigint example: "0xdeadbeaf" init: $ref: '#/components/schemas/StateInit' @@ -3697,6 +3935,7 @@ components: - cskip_no_state - cskip_bad_state - cskip_no_gas + - cskip_suspended BouncePhaseType: type: string example: cskip_no_state @@ -4115,10 +4354,10 @@ components: example: 1000000 zerostate_root_hash: type: string - example: 1000000 + example: "131D0C65055F04E9C19D687B51BC70F952FD9CA6F02C2801D3B89964A779DF85" zerostate_file_hash: type: string - example: 1000000 + example: "A6A0BD6608672B11B79538A50B2204E748305C12AA0DED9C16CF0006CE3AF8DB" version: type: integer format: int64 @@ -4235,6 +4474,7 @@ components: type: integer total_weight: type: string + x-js-format: bigint example: "1152921504606846800" list: type: array @@ -4252,6 +4492,7 @@ components: x-js-format: bigint adnl_addr: type: string + example: "45061C1D4EC44A937D0318589E13C73D151D1CEF5D3C0E53AFBCF56A6C2FE2BD" Oracle: type: object required: @@ -4445,9 +4686,9 @@ components: x-js-format: bigint example: 123456789 extra_balance: - type: object - additionalProperties: - type: string + type: array + items: + $ref: '#/components/schemas/ExtraCurrency' code: type: string format: cell @@ -4485,6 +4726,126 @@ components: root: type: string format: cell + BlockchainLibrary: + type: object + required: + - boc + properties: + boc: + type: string + format: cell + example: b5ee9c7201010101005f0000baff0020dd2082014c97ba218201339cbab19c71b0ed44d0d31fd70bffe304e0a4f260810200d71820d70b1fed44d0d31fd3ffd15112baf2a122f901541044f910f2a2f80001d31f3120d74a96d307d402fb00ded1a4c8cb1fcbffc9ed54 + WalletStats: + type: object + required: + - nfts_count + - jettons_count + - multisig_count + - staking_count + properties: + nfts_count: + type: integer + format: int32 + example: 123456789 + jettons_count: + type: integer + format: int32 + example: 123456789 + multisig_count: + type: integer + format: int32 + example: 123456789 + staking_count: + type: integer + format: int32 + example: 123456789 + WalletPlugin: + type: object + required: + - address + - type + - status + properties: + address: + type: string + format: address + example: 0:da6b1b6663a0e4d18cc8574ccd9db5296e367dd9324706f3bbd9eb1cd2caf0bf + type: + type: string + example: "subscription_v1" + status: + '$ref': '#/components/schemas/AccountStatus' + Wallets: + type: object + required: + - accounts + properties: + accounts: + type: array + items: + $ref: '#/components/schemas/Wallet' + Wallet: + type: object + required: + - address + - balance + - stats + - plugins + - status + - last_activity + - get_methods + - is_wallet + - last_lt + properties: + address: + type: string + format: address + example: 0:da6b1b6663a0e4d18cc8574ccd9db5296e367dd9324706f3bbd9eb1cd2caf0bf + is_wallet: + type: boolean + balance: + type: integer + format: int64 + example: 123456789 + x-js-format: bigint + stats: + $ref: '#/components/schemas/WalletStats' + plugins: + type: array + items: + $ref: '#/components/schemas/WalletPlugin' + status: + '$ref': '#/components/schemas/AccountStatus' + last_activity: + type: integer + description: unix timestamp + format: int64 + example: 1720860269 + name: + type: string + example: "Ton foundation" + icon: + type: string + example: "https://ton.org/logo.png" + get_methods: + type: array + deprecated: true + items: + type: string + example: [ 'get_item_data' ] + is_suspended: + type: boolean + signature_disabled: + type: boolean + interfaces: + type: array + items: + type: string + last_lt: + type: integer + format: int64 + example: 25713146000001 + x-js-format: bigint Account: type: object required: @@ -4504,6 +4865,10 @@ components: format: int64 example: 123456789 x-js-format: bigint + extra_balance: + type: array + items: + $ref: '#/components/schemas/ExtraCurrency' currencies_balance: description: "{'USD': 1, 'IDR': 1000}" type: object @@ -4585,6 +4950,8 @@ components: example: 0:da6b1b6663a0e4d18cc8574ccd9db5296e367dd9324706f3bbd9eb1cd2caf0bf amount: type: string + # x-js-format: bigint + # example: "1000000" nanocoins or decimal ? description: "Number of nanocoins to send. Decimal string." payload: type: string @@ -4594,6 +4961,13 @@ components: type: string format: cell description: "Raw once-cell BoC encoded in hex." + GaslessTx: + type: object + required: + - protocol_name + properties: + protocol_name: + type: string SignRawParams: type: object required: @@ -4602,15 +4976,19 @@ components: - commission - from - valid_until + - protocol_name properties: + protocol_name: + type: string relay_address: type: string format: address example: 0:da6b1b6663a0e4d18cc8574ccd9db5296e367dd9324706f3bbd9eb1cd2caf0bf commission: type: string - description: "Commission for the transaction. In nanocoins." + x-js-format: bigint example: "1000000" + description: "Commission for the transaction. In nanocoins." from: type: string format: address @@ -4623,6 +5001,8 @@ components: type: array items: $ref: '#/components/schemas/SignRawMessage' + emulation: + $ref: '#/components/schemas/MessageConsequences' MethodExecutionResult: type: object required: @@ -4762,6 +5142,8 @@ components: format: int64 amount: type: string + # x-js-format: bigint + # example: "1000000" "8": type: object description: The network version and additional capabilities supported by the validators. @@ -4901,10 +5283,16 @@ components: properties: min_stake: type: string + # x-js-format: bigint + # example: "1000000" max_stake: type: string + # x-js-format: bigint + # example: "1000000" min_total_stake: type: string + # x-js-format: bigint + # example: "1000000" max_stake_factor: type: integer format: int64 @@ -5139,6 +5527,27 @@ components: example: 0:0000000000000000000000000000000000000000000000000000000000000000 suspended_until: type: integer + + "45": + type: object + description: precompiled contracts + required: + - contracts + properties: + contracts: + type: array + items: + type: object + required: + - code_hash + - gas_usage + properties: + code_hash: + type: string + format: address + gas_usage: + type: integer + format: int64 "71": type: object description: Bridge parameters for wrapping TON in other networks. @@ -5236,6 +5645,7 @@ components: type: string enum: - whitelist + - graylist - blacklist - none JettonPreview: @@ -5247,6 +5657,7 @@ components: - decimals - verification - image + - score properties: address: type: string @@ -5266,6 +5677,11 @@ components: example: https://cache.tonapi.io/images/jetton.jpg verification: $ref: '#/components/schemas/JettonVerificationType' + custom_payload_api_uri: # todo: maybe remove + type: string + score: + type: integer + format: int32 JettonBalance: type: object required: @@ -5275,7 +5691,8 @@ components: properties: balance: type: string - example: 597968399 + x-js-format: bigint + example: "597968399" price: $ref: '#/components/schemas/TokenRates' wallet_address: @@ -5297,7 +5714,8 @@ components: properties: amount: type: string - example: 597968399 + x-js-format: bigint + example: "597968399" till: type: integer format: int64 @@ -5311,18 +5729,57 @@ components: type: array items: $ref: '#/components/schemas/JettonBalance' + CurrencyType: + type: string + example: jetton + enum: + - native + - extra_currency + - jetton + - fiat + VaultDepositInfo: + type: object + required: + - price + - vault + properties: + price: + $ref: "#/components/schemas/Price" + vault: + type: string + format: address + example: 0:0BB5A9F69043EEBDDA5AD2E946EB953242BD8F603FE795D90698CEEC6BFC60A0 Price: type: object required: + - currency_type - value + - decimals - token_name + - verification + - image properties: + currency_type: + $ref: '#/components/schemas/CurrencyType' value: type: string + x-js-format: bigint example: "123000000000" + decimals: + type: integer + example: 9 token_name: type: string example: TON + verification: + $ref: '#/components/schemas/TrustType' + image: + type: string + example: https://cache.tonapi.io/images/jetton.jpg + jetton: + type: string + format: address + example: 0:0BB5A9F69043EEBDDA5AD2E946EB953242BD8F603FE795D90698CEEC6BFC60A0 ImagePreview: type: object required: @@ -5343,7 +5800,6 @@ components: enum: - getgems - tonkeeper - - ton.diamonds TrustType: type: string example: whitelist @@ -5408,6 +5864,7 @@ components: example: "Best collection in TON network" verified: type: boolean + description: "Collection master contract confirmed that this item is part of collection" example: true metadata: type: object @@ -5423,7 +5880,10 @@ components: type: string example: crypto.ton approved_by: - $ref: '#/components/schemas/NftApprovedBy' + allOf: + - $ref: '#/components/schemas/NftApprovedBy' + deprecated: true + description: Please use trust field include_cnft: type: boolean example: false @@ -5462,9 +5922,7 @@ components: format: address example: "0:da6b1b6663a0e4d18cc8574ccd9db5296e367dd9324706f3bbd9eb1cd2caf0bf" seqno: - type: integer - format: int64 - example: 1 + type: string threshold: type: integer format: int32 @@ -5495,15 +5953,16 @@ components: - approvals_num - expiration_date - risk + - creation_date + - signed_by + - multisig_address properties: address: type: string format: address example: "0:da6b1b6663a0e4d18cc8574ccd9db5296e367dd9324706f3bbd9eb1cd2caf0bf" order_seqno: - type: integer - format: int64 - example: 1 + type: string threshold: type: integer format: int32 @@ -5524,6 +5983,40 @@ components: format: int64 risk: $ref: '#/components/schemas/Risk' + creation_date: + type: integer + format: int64 + signed_by: + type: array + items: + type: string + format: address + example: "0:da6b1b6663a0e4d18cc8574ccd9db5296e367dd9324706f3bbd9eb1cd2caf0bf" + multisig_address: + type: string + format: address + example: "0:da6b1b6663a0e4d18cc8574ccd9db5296e367dd9324706f3bbd9eb1cd2caf0bf" + changing_parameters: + type: object + required: + - threshold + - signers + - proposers + properties: + threshold: + type: integer + format: int32 + signers: + type: array + items: + type: string + format: address + example: "0:da6b1b6663a0e4d18cc8574ccd9db5296e367dd9324706f3bbd9eb1cd2caf0bf" + proposers: + type: array + items: + type: string + format: address Refund: type: object required: @@ -5565,6 +6058,7 @@ components: type: object required: - account + - qty - quantity - jetton properties: @@ -5572,8 +6066,13 @@ components: $ref: '#/components/schemas/AccountAddress' jetton: $ref: '#/components/schemas/JettonPreview' + qty: + type: string + x-js-format: bigint + example: "200" quantity: type: integer + deprecated: true format: int64 x-js-format: bigint example: 10 @@ -5590,11 +6089,12 @@ components: example: "TonTransfer" enum: - TonTransfer + - ExtraCurrencyTransfer + - ContractDeploy - JettonTransfer - JettonBurn - JettonMint - NftItemTransfer - - ContractDeploy - Subscribe - UnSubscribe - AuctionBid @@ -5602,13 +6102,19 @@ components: - DepositStake - WithdrawStake - WithdrawStakeRequest + - ElectionsDepositStake + - ElectionsRecoverStake - JettonSwap - SmartContractExec - - ElectionsRecoverStake - - ElectionsDepositStake - DomainRenew - - InscriptionTransfer - - InscriptionMint + - Purchase + - AddExtension + - RemoveExtension + - SetSignatureAllowedAction + - GasRelay + - DepositTokenStake + - WithdrawTokenStakeRequest + - LiquidityDeposit - Unknown status: type: string @@ -5618,6 +6124,8 @@ components: - failed TonTransfer: $ref: '#/components/schemas/TonTransferAction' + ExtraCurrencyTransfer: + $ref: '#/components/schemas/ExtraCurrencyTransferAction' ContractDeploy: $ref: '#/components/schemas/ContractDeployAction' JettonTransfer: @@ -5652,10 +6160,22 @@ components: $ref: '#/components/schemas/SmartContractAction' DomainRenew: $ref: '#/components/schemas/DomainRenewAction' - InscriptionTransfer: - $ref: '#/components/schemas/InscriptionTransferAction' - InscriptionMint: - $ref: '#/components/schemas/InscriptionMintAction' + Purchase: + $ref: '#/components/schemas/PurchaseAction' + AddExtension: + $ref: '#/components/schemas/AddExtensionAction' + RemoveExtension: + $ref: '#/components/schemas/RemoveExtensionAction' + SetSignatureAllowedAction: + $ref: '#/components/schemas/SetSignatureAllowedAction' + GasRelay: + $ref: '#/components/schemas/GasRelayAction' + DepositTokenStake: + $ref: '#/components/schemas/DepositTokenStakeAction' + WithdrawTokenStakeRequest: + $ref: '#/components/schemas/WithdrawTokenStakeRequestAction' + LiquidityDeposit: + $ref: '#/components/schemas/LiquidityDepositAction' simple_preview: $ref: '#/components/schemas/ActionSimplePreview' base_transactions: @@ -5688,6 +6208,60 @@ components: $ref: '#/components/schemas/EncryptedComment' refund: $ref: '#/components/schemas/Refund' + ExtraCurrencies: + type: object + required: + - extra_currencies + properties: + extra_currencies: + type: array + items: + $ref: '#/components/schemas/EcPreview' + EcPreview: + type: object + required: + - id + - symbol + - decimals + - image + properties: + id: + type: integer + example: 239 + format: int32 + symbol: + type: string + example: FMS + decimals: + type: integer + example: 5 + image: + type: string + example: https://cache.tonapi.io/images/extra.jpg + ExtraCurrencyTransferAction: + type: object + required: + - sender + - recipient + - amount + - currency + properties: + sender: + $ref: '#/components/schemas/AccountAddress' + recipient: + $ref: '#/components/schemas/AccountAddress' + amount: + type: string + x-js-format: bigint + example: "1000000000" + description: amount in quanta of tokens + comment: + type: string + example: "Hi! This is your salary. \nFrom accounting with love." + encrypted_comment: + $ref: '#/components/schemas/EncryptedComment' + currency: + $ref: '#/components/schemas/EcPreview' SmartContractAction: type: object required: @@ -5711,6 +6285,7 @@ components: example: "NftTransfer or 0x35d95a12" payload: type: string + # example ??, maybe cell? refund: $ref: '#/components/schemas/Refund' DomainRenewAction: @@ -5729,66 +6304,76 @@ components: example: "0:da6b1b6663a0e4d18cc8574ccd9db5296e367dd9324706f3bbd9eb1cd2caf0bf" renewer: $ref: '#/components/schemas/AccountAddress' - InscriptionMintAction: + GasRelayAction: type: object required: - - type - - ticker - - recipient - amount - - decimals + - relayer + - target properties: - recipient: - $ref: '#/components/schemas/AccountAddress' amount: - type: string - description: amount in minimal particles - example: "123456789" - type: - type: string - enum: - - ton20 - - gram20 - example: "ton20" - ticker: - type: string - example: "nano" - decimals: type: integer - example: 9 - InscriptionTransferAction: + format: int64 + x-js-format: bigint + example: 1000000000 + relayer: + $ref: '#/components/schemas/AccountAddress' + target: + $ref: '#/components/schemas/AccountAddress' + PurchaseAction: type: object required: - - sender - - recipient + - source + - destination + - invoice_id - amount - - type - - ticker - - decimals + - metadata properties: - sender: + source: $ref: '#/components/schemas/AccountAddress' - recipient: + destination: $ref: '#/components/schemas/AccountAddress' - amount: - type: string - description: amount in minimal particles - example: "123456789" - comment: + invoice_id: type: string - example: "Hi! This is your salary. \nFrom accounting with love." - type: + example: 03cfc582-b1c3-410a-a9a7-1f3afe326b3b + amount: + $ref: '#/components/schemas/Price' + metadata: + $ref: '#/components/schemas/Metadata' + AddExtensionAction: + type: object + required: + - wallet + - extension + properties: + wallet: + $ref: '#/components/schemas/AccountAddress' + extension: type: string - enum: - - ton20 - - gram20 - example: "ton20" - ticker: + format: address + example: 0:10C1073837B93FDAAD594284CE8B8EFF7B9CF25427440EB2FC682762E1471365 + RemoveExtensionAction: + type: object + required: + - wallet + - extension + properties: + wallet: + $ref: '#/components/schemas/AccountAddress' + extension: type: string - example: "nano" - decimals: - type: integer - example: 9 + format: address + example: 0:10C1073837B93FDAAD594284CE8B8EFF7B9CF25427440EB2FC682762E1471365 + SetSignatureAllowedAction: + type: object + required: + - wallet + - allowed + properties: + wallet: + $ref: '#/components/schemas/AccountAddress' + allowed: + type: boolean NftItemTransferAction: type: object required: @@ -5834,8 +6419,9 @@ components: example: 0:E93E7D444180608B8520C00DC664383A387356FB6E16FDDF99DBE5E1415A574B amount: type: string + x-js-format: bigint + example: "1000000000" description: amount in quanta of tokens - example: 1000000000 comment: type: string example: "Hi! This is your salary. \nFrom accounting with love." @@ -5861,8 +6447,9 @@ components: example: 0:E93E7D444180608B8520C00DC664383A387356FB6E16FDDF99DBE5E1415A574B amount: type: string + x-js-format: bigint + example: "1000000000" description: amount in quanta of tokens - example: 1000000000 jetton: $ref: '#/components/schemas/JettonPreview' JettonMintAction: @@ -5881,8 +6468,9 @@ components: example: 0:E93E7D444180608B8520C00DC664383A387356FB6E16FDDF99DBE5E1415A574B amount: type: string + x-js-format: bigint + example: "1000000000" description: amount in quanta of tokens - example: 1000000000 jetton: $ref: '#/components/schemas/JettonPreview' ContractDeployAction: @@ -5906,7 +6494,8 @@ components: - subscriber - subscription - beneficiary - - amount + - admin + - price - initial properties: subscriber: @@ -5917,11 +6506,16 @@ components: example: "0:da6b1b6663a0e4d18cc8574ccd9db5296e367dd9324706f3bbd9eb1cd2caf0bf" beneficiary: $ref: '#/components/schemas/AccountAddress' + admin: + $ref: '#/components/schemas/AccountAddress' amount: + deprecated: true type: integer format: int64 example: 1000000000 x-js-format: bigint + price: + $ref: '#/components/schemas/Price' initial: type: boolean example: false @@ -5931,6 +6525,7 @@ components: - subscriber - subscription - beneficiary + - admin properties: subscriber: $ref: '#/components/schemas/AccountAddress' @@ -5940,6 +6535,8 @@ components: example: "0:da6b1b6663a0e4d18cc8574ccd9db5296e367dd9324706f3bbd9eb1cd2caf0bf" beneficiary: $ref: '#/components/schemas/AccountAddress' + admin: + $ref: '#/components/schemas/AccountAddress' AuctionBidAction: type: object required: @@ -6059,15 +6656,14 @@ components: properties: dex: type: string - enum: - - stonfi - - dedust - - megatonfi + example: "stonfi" amount_in: type: string + x-js-format: bigint example: "1660050553" amount_out: type: string + x-js-format: bigint example: "1660050553" ton_in: type: integer @@ -6111,6 +6707,45 @@ components: $ref: '#/components/schemas/AccountAddress' buyer: $ref: '#/components/schemas/AccountAddress' + DepositTokenStakeAction: + type: object + required: + - staker + - protocol + properties: + staker: + $ref: '#/components/schemas/AccountAddress' + protocol: + $ref: '#/components/schemas/Protocol' + stake_meta: + $ref: '#/components/schemas/Price' + WithdrawTokenStakeRequestAction: + type: object + required: + - staker + - protocol + properties: + staker: + $ref: '#/components/schemas/AccountAddress' + protocol: + $ref: '#/components/schemas/Protocol' + stake_meta: + $ref: '#/components/schemas/Price' + LiquidityDepositAction: + type: object + required: + - protocol + - from + - tokens + properties: + protocol: + $ref: '#/components/schemas/Protocol' + from: + $ref: '#/components/schemas/AccountAddress' + tokens: + type: array + items: + $ref: '#/components/schemas/VaultDepositInfo' ActionSimplePreview: type: object description: shortly describes what this action is about. @@ -6150,6 +6785,7 @@ components: - lt - in_progress - extra + - progress properties: event_id: type: string @@ -6182,20 +6818,87 @@ components: type: integer format: int64 example: 3 + progress: + type: number + format: float + minimum: 0 + maximum: 1 + example: 0.5 AccountEvents: type: object required: - - events + - events + - next_from + properties: + events: + type: array + items: + $ref: '#/components/schemas/AccountEvent' + next_from: + type: integer + format: int64 + example: 25713146000001 + Purchase: + type: object + required: + - event_id + - invoice_id + - source + - destination + - lt + - utime + - amount + - metadata + properties: + event_id: + type: string + example: e8b0e3fee4a26bd2317ac1f9952fcdc87dc08fdb617656b5202416323337372e + invoice_id: + type: string + example: 03cfc582-b1c3-410a-a9a7-1f3afe326b3b + source: + $ref: '#/components/schemas/AccountAddress' + destination: + $ref: '#/components/schemas/AccountAddress' + lt: + type: integer + format: int64 + example: 25713146000001 + x-js-format: bigint + utime: + type: integer + format: int64 + example: 1645544908 + amount: + $ref: '#/components/schemas/Price' + metadata: + $ref: '#/components/schemas/Metadata' + AccountPurchases: + type: object + required: + - purchases - next_from properties: - events: + purchases: type: array items: - $ref: '#/components/schemas/AccountEvent' + $ref: '#/components/schemas/Purchase' next_from: type: integer format: int64 example: 25713146000001 + Metadata: + type: object + required: + - encrypted_binary + properties: + encrypted_binary: + type: string + description: hex encoded bytes + decryption_key: + type: string + description: hex encoded bytes + example: "dead.....beef" TraceID: type: object required: @@ -6231,62 +6934,52 @@ components: Subscription: type: object required: - - address - - wallet_address - - beneficiary_address - - amount + - type + - status - period - - start_time - - timeout - - last_payment_time - - last_request_time - subscription_id - - failed_attempts + - payment_per_period + - wallet + - next_charge_at + - metadata properties: - address: - type: string - format: address - example: 0:dea8f638b789172ce36d10a20318125e52c649aa84893cd77858224fe2b9b0ee - wallet_address: + type: type: string - format: address - example: 0:567DE86AF2B6A557D7085807CF7C26338124987A5179344F0D0FA2657EB710F1 - beneficiary_address: + description: type of subscription + example: v2 + status: type: string - format: address - example: 0:c704dadfabac88eab58e340de03080df81ff76636431f48624ad6e26fb2da0a4 - amount: - type: integer - format: int64 - example: 1000000000 + enum: + - not_ready + - active + - suspended + - cancelled period: type: integer + description: payment period in seconds format: int64 example: 2592000 - start_time: - type: integer - format: int64 - example: 1653996832 - timeout: - type: integer - format: int64 - example: 10800 - last_payment_time: - type: integer - format: int64 - example: 1653996834 - last_request_time: - type: integer - format: int64 - example: 0 subscription_id: + type: string + description: common identifier + payment_per_period: + $ref: '#/components/schemas/Price' + wallet: + $ref: '#/components/schemas/AccountAddress' + next_charge_at: type: integer format: int64 - example: 217477 - failed_attempts: - type: integer - format: int32 - example: 0 + example: 1653996834 + metadata: + $ref: '#/components/schemas/Metadata' + address: + type: string + format: address + example: 0:dea8f638b789172ce36d10a20318125e52c649aa84893cd77858224fe2b9b0ee + beneficiary: + $ref: '#/components/schemas/AccountAddress' + admin: + $ref: '#/components/schemas/AccountAddress' Subscriptions: type: object required: @@ -6502,6 +7195,10 @@ components: type: array items: $ref: '#/components/schemas/NftItem' + total_equivalent: + type: number + format: float + description: "Estimated equivalent value of all assets at risk in selected currency (for example USD)" JettonQuantity: type: object required: @@ -6511,6 +7208,7 @@ components: properties: quantity: type: string + x-js-format: bigint example: "597968399" wallet_address: $ref: '#/components/schemas/AccountAddress' @@ -6584,6 +7282,20 @@ components: type: array items: $ref: '#/components/schemas/DecodedRawMessage' + wallet_v5: + type: object + required: + - raw_messages + - valid_until + properties: + valid_until: + type: integer + format: int64 + example: 1 + raw_messages: + type: array + items: + $ref: '#/components/schemas/DecodedRawMessage' wallet_highload_v2: type: object required: @@ -6621,6 +7333,7 @@ components: example: "nft_transfer" op_code: type: string + x-js-format: bigint example: "0xdeadbeaf" decoded_body: { } # Free-form JSON value mode: @@ -6636,6 +7349,7 @@ components: - is_scam - lt - in_progress + - progress properties: event_id: type: string @@ -6665,6 +7379,12 @@ components: type: boolean example: false description: Event is not finished yet. Transactions still happening + progress: + type: number + format: float + minimum: 0 + maximum: 1 + example: 0.5 JettonMetadata: type: object required: @@ -6688,7 +7408,8 @@ components: example: "9" image: type: string - example: "https://cache.tonapi.io/images/jetton.jpg" + example: "https://bitcoincash-example.github.io/website/logo.png" + description: this field currently returns a cached image URL (e.g., "https://cache.tonapi.io/images/jetton.jpg"). In the future, this will be replaced with the original URL from the metadata. The cached image is already available in the `preview` field of `JettonInfo` and will remain there. description: type: string example: Wrapped Toncoin @@ -6707,39 +7428,9 @@ components: items: type: string example: [ "https://coinmarketcap.com/currencies/drv/", "https://www.coingecko.com/en/coins/durov" ] - InscriptionBalances: - type: object - required: - - inscriptions - properties: - inscriptions: - type: array - items: - $ref: '#/components/schemas/InscriptionBalance' - InscriptionBalance: - type: object - required: - - type - - ticker - - balance - - decimals - properties: - type: - type: string - enum: - - ton20 - - gram20 - example: "ton20" - ticker: + custom_payload_api_uri: type: string - example: "nano" - balance: - type: string - example: "1000000000" - decimals: - type: integer - example: 9 - + example: "https://claim-api.tonapi.io/jettons/TESTMINT" Jettons: type: object required: @@ -6757,17 +7448,22 @@ components: - metadata - verification - holders_count + - preview properties: mintable: type: boolean example: true total_supply: type: string + x-js-format: bigint example: "5887105890579978" admin: $ref: '#/components/schemas/AccountAddress' metadata: $ref: '#/components/schemas/JettonMetadata' + preview: + type: string + example: "https://cache.tonapi.io/images/jetton.jpg" verification: $ref: '#/components/schemas/JettonVerificationType' holders_count: @@ -6797,6 +7493,7 @@ components: $ref: '#/components/schemas/AccountAddress' balance: type: string + x-js-format: bigint example: "168856200518084" description: balance in the smallest jetton's units total: @@ -6807,16 +7504,18 @@ components: JettonTransferPayload: type: object required: - - payload + - payload properties: custom_payload: type: string - description: "hex-encoded BoC" + # format: ??? example: "b5ee9c72410212010001b40009460395b521c9251151ae7987e03c544bd275d6cd42c2d157f840beb14d5454b96718000d012205817002020328480101fd7f6a648d4f771d7f0abc1707e4e806b19de1801f65eb8c133a4cfb0c33d847000b22012004052848010147da975b922d89192f4c9b68a640daa6764ec398c93cec025e17f0c1852a711a0009220120061122012007082848010170d9fb0423cbef6c2cf1f3811a2f640daf8c9a326b6f8816c1b993e90d88e2100006220120090a28480101f6df1d75f6b9e45f224b2cb4fc2286d927d47b468b6dbf1fedc4316290ec2ae900042201200b102201200c0f2201200d" + description: "hex-encoded BoC" state_init: type: string - description: "hex-encoded BoC" + # format: ??? example: "b5ee9c72410212010001b40009460395b521c9251151ae7987e03c544bd275d6cd42c2d157f840beb14d5454b96718000d012205817002020328480101fd7f6a648d4f771d7f0abc1707e4e806b19de1801f65eb8c133a4cfb0c33d847000b22012004052848010147da975b922d89192f4c9b68a640daa6764ec398c93cec025e17f0c1852a711a0009220120061122012007082848010170d9fb0423cbef6c2cf1f3811a2f640daf8c9a326b6f8816c1b993e90d88e2100006220120090a28480101f6df1d75f6b9e45f224b2cb4fc2286d927d47b468b6dbf1fedc4316290ec2ae900042201200b102201200c0f2201200d" + description: "hex-encoded BoC" AccountStaking: type: object required: @@ -7008,6 +7707,7 @@ components: - address - name - preview + - trust properties: address: type: string @@ -7018,6 +7718,8 @@ components: preview: type: string example: "https://cache.tonapi.io/images/media.jpg" + trust: + $ref: '#/components/schemas/TrustType' DnsExpiring: type: object required: @@ -7040,6 +7742,19 @@ components: example: "blah_blah.ton" dns_item: $ref: '#/components/schemas/NftItem' + ChartPoints: + type: array + items: + type: array + minItems: 2 + maxItems: 2 + items: + type: number + description: | + Each inner array is a pair [timestamp, price]: + • index 0 — Unix timestamp (int64) + • index 1 — token price (decimal) in the requested currency. + example: [ [ 1668436763, 97.21323234 ] ] AccountInfoByStateInit: type: object required: @@ -7076,7 +7791,8 @@ components: format: int32 shard: type: string - example: 800000000000000 + # x-js-format: bigint ?? + example: "800000000000000" seqno: type: integer example: 30699640 @@ -7122,30 +7838,27 @@ components: - code - code_hash - methods + - compiler properties: code: type: string format: cell + disassembled_code: + type: string code_hash: type: string methods: type: array items: - type: object - required: - - id - - method - properties: - id: - type: integer - format: int64 - method: - type: string - example: "get_something" + $ref: '#/components/schemas/Method' compiler: type: string enum: - func + - fift + - tact + source: + $ref: '#/components/schemas/Source' PoolImplementationType: type: string enum: @@ -7196,7 +7909,209 @@ components: type: integer format: int64 example: 1668436763 - + ExtraCurrency: + type: object + required: + - amount + - preview + properties: + amount: + type: string + x-js-format: bigint + example: "1000000000" + preview: + $ref: '#/components/schemas/EcPreview' + SourceFile: + type: object + required: + - name + - content + - is_entrypoint + - is_std_lib + - include_in_command + properties: + name: + type: string + content: + type: string + is_entrypoint: + type: boolean + example: false + is_std_lib: + type: boolean + example: false + include_in_command: + type: boolean + example: false + Source: + type: object + required: + - files + properties: + files: + type: array + items: + $ref: '#/components/schemas/SourceFile' + Method: + type: object + required: + - id + - method + properties: + id: + type: integer + format: int64 + method: + type: string + example: "get_something" + NftOperations: + type: object + required: + - operations + properties: + operations: + type: array + items: + $ref: '#/components/schemas/NftOperation' + next_from: + type: integer + format: int64 + example: 25713146000001 + x-js-format: bigint + NftOperation: + type: object + required: + - operation + - utime + - lt + - transaction_hash + - item + properties: + operation: + type: string + example: "transfer" + utime: + type: integer + format: int64 + example: 1234567890 + lt: + type: integer + format: int64 + example: 25713146000001 + x-js-format: bigint + transaction_hash: + type: string + example: "0xdeadbeaf" + source: + $ref: '#/components/schemas/AccountAddress' + destination: + $ref: '#/components/schemas/AccountAddress' + item: + $ref: '#/components/schemas/NftItem' + JettonOperations: + type: object + required: + - operations + properties: + operations: + type: array + items: + $ref: '#/components/schemas/JettonOperation' + next_from: + type: integer + format: int64 + example: 25713146000001 + x-js-format: bigint + JettonOperation: + type: object + required: + - operation + - utime + - lt + - jetton + - transaction_hash + - amount + - trace_id + - query_id + properties: + operation: + type: string + example: "transfer" + enum: [ "transfer", "mint", "burn" ] + utime: + type: integer + format: int64 + example: 1234567890 + lt: + type: integer + format: int64 + example: 25713146000001 + x-js-format: bigint + transaction_hash: + type: string + example: "cbf3e3d70ecf6f69643dd430761cd6004de2cacbdbc3029b0abd30ca3cc1c67e" + source: + $ref: '#/components/schemas/AccountAddress' + destination: + $ref: '#/components/schemas/AccountAddress' + amount: + type: string + x-js-format: bigint + example: "1000000000" + jetton: + $ref: '#/components/schemas/JettonPreview' + trace_id: + type: string + example: "8fa19eec7bd6d00d0d76048cebe31e34082a859410c9fcf7d55ef4ff8f7fcb47" + query_id: + type: string + example: "17286061481122318000" + x-js-format: bigint + payload: { } # free from json + ExecGetMethodArgType: + type: string + description: | + Data type of the argument value: + - `nan`: Not-a-Number value + - `null`: Null value + - `tinyint`: Decimal integer (e.g., `100500`) + - `int257`: 257-bit integer in hex format with 0x prefix (e.g., `0xfa01d78381ae32`) + - `slice`: TON blockchain address (e.g., `0:6e731f2e...`) + - `cell_boc_base64`: Base64-encoded cell BOC (Binary Object Code) (e.g., `te6ccgEBAQEAAgAAAA==`) + - `slice_boc_hex`: Hex-encoded slice BOC (e.g., `b5ee9c72...`) + enum: + - "nan" + - "null" + - "tinyint" + - "int257" + - "slice" + - "cell_boc_base64" + - "slice_boc_hex" + example: int257 + ExecGetMethodArg: + type: object + required: + - type + - value + properties: + type: + $ref: '#/components/schemas/ExecGetMethodArgType' + value: + type: string + description: String representation of the value according to the specified type + example: "0xfa01d78381ae32" + Protocol: + type: object + required: + - name + properties: + name: + type: string + example: "Ethena" + image: + type: string + example: https://cache.tonapi.io/images/jetton.jpg + responses: Error: description: Some error during request processing @@ -7209,3 +8124,6 @@ components: properties: error: type: string + error_code: + type: integer + format: int64 \ No newline at end of file diff --git a/client.go b/client.go index 40bb0b6..ba1166b 100644 --- a/client.go +++ b/client.go @@ -1,25 +1,27 @@ package tonapi import ( - "fmt" - "net/http" - - ht "github.com/ogen-go/ogen/http" + "context" + "github.com/ogen-go/ogen/ogenerrors" ) -type clientWithApiKey struct { - header string +type Security struct { + Token string } -func (c clientWithApiKey) Do(r *http.Request) (*http.Response, error) { - r.Header.Set("Authorization", c.header) - return http.DefaultClient.Do(r) +// BearerAuth returns the Bearer authentication credentials for the client. +// If the token is not provided, it skips the security check by returning `ErrSkipClientSecurity`. +// This method is used to authenticate API requests using the Bearer token. +func (s *Security) BearerAuth(ctx context.Context, operationName OperationName, client *Client) (BearerAuth, error) { + if s.Token == "" { + return BearerAuth{}, ogenerrors.ErrSkipClientSecurity + } + return BearerAuth{Token: s.Token}, nil } -var _ ht.Client = &clientWithApiKey{} - -// WithToken configures client to use tonApiKey for authorization. -// When working with tonapi.io, you should consider getting an API key at https://tonconsole.com/. +// WithToken configures the Security object with the provided token for Bearer authentication. +// The token will be used to authorize API requests to tonapi.io. +// To obtain a token, register and generate an API key at https://tonconsole.com. // // Example: // @@ -30,21 +32,21 @@ var _ ht.Client = &clientWithApiKey{} // ) // // func main() { -// cli, _ := tonapi.New(tonapi.WithToken(tonapiKey)) +// token := "your-api-token" +// client, err := tonapi.NewClient(tonapi.TonApiURL, tonapi.WithToken(token)) +// if err != nil { +// // handle error +// } +// // use client // } -func WithToken(tonApiKey string) ClientOption { - return WithClient(&clientWithApiKey{header: fmt.Sprintf("Bearer %s", tonApiKey)}) +func WithToken(token string) *Security { + return &Security{Token: token} } +// TonApiURL is the endpoint for working with the mainnet. const TonApiURL = "https://tonapi.io" -// TestnetTonApiURL is an endpoint to work with testnet. -// +// TestnetTonApiURL is the endpoint for working with the testnet. // Example: // client, err := NewClient(tonapi.TestnetTonApiURL) const TestnetTonApiURL = "https://testnet.tonapi.io" - -// New returns a new Client. -func New(opts ...ClientOption) (*Client, error) { - return NewClient(TonApiURL, opts...) -} diff --git a/examples/gasless/go.mod b/examples/gasless/go.mod index b10fab5..633f654 100644 --- a/examples/gasless/go.mod +++ b/examples/gasless/go.mod @@ -1,44 +1,46 @@ module github.com/tonkeeper.tonapi-go/examples/gasless -go 1.22.0 +go 1.23.0 + +toolchain go1.24.1 require ( github.com/shopspring/decimal v1.4.0 - github.com/tonkeeper/tonapi-go v0.0.5 + github.com/tonkeeper/tonapi-go v0.0.13 github.com/tonkeeper/tongo v1.9.0 ) require ( - github.com/dlclark/regexp2 v1.10.0 // indirect - github.com/fatih/color v1.15.0 // indirect + github.com/dlclark/regexp2 v1.11.4 // indirect + github.com/fatih/color v1.18.0 // indirect github.com/ghodss/yaml v1.0.0 // indirect - github.com/go-faster/errors v0.6.1 // indirect + github.com/go-faster/errors v0.7.1 // indirect github.com/go-faster/jx v1.1.0 // indirect github.com/go-faster/yaml v0.4.6 // indirect - github.com/go-logr/logr v1.2.4 // indirect + github.com/go-logr/logr v1.4.2 // indirect github.com/go-logr/stdr v1.2.2 // indirect - github.com/google/uuid v1.4.0 // indirect + github.com/google/uuid v1.6.0 // indirect github.com/gorilla/websocket v1.5.1 // indirect github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-isatty v0.0.20 // indirect github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae // indirect - github.com/ogen-go/ogen v0.77.0 // indirect + github.com/ogen-go/ogen v1.8.1 // indirect github.com/r3labs/sse/v2 v2.10.0 // indirect github.com/segmentio/asm v1.2.0 // indirect github.com/snksoft/crc v1.1.0 // indirect - go.opentelemetry.io/otel v1.19.0 // indirect - go.opentelemetry.io/otel/metric v1.19.0 // indirect - go.opentelemetry.io/otel/trace v1.19.0 // indirect + go.opentelemetry.io/otel v1.32.0 // indirect + go.opentelemetry.io/otel/metric v1.32.0 // indirect + go.opentelemetry.io/otel/trace v1.32.0 // indirect go.uber.org/multierr v1.11.0 // indirect - go.uber.org/zap v1.26.0 // indirect - golang.org/x/crypto v0.21.0 // indirect + go.uber.org/zap v1.27.0 // indirect + golang.org/x/crypto v0.35.0 // indirect golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 // indirect - golang.org/x/mod v0.13.0 // indirect - golang.org/x/net v0.23.0 // indirect - golang.org/x/sync v0.4.0 // indirect - golang.org/x/sys v0.18.0 // indirect - golang.org/x/text v0.14.0 // indirect - golang.org/x/tools v0.14.0 // indirect + golang.org/x/mod v0.22.0 // indirect + golang.org/x/net v0.36.0 // indirect + golang.org/x/sync v0.11.0 // indirect + golang.org/x/sys v0.30.0 // indirect + golang.org/x/text v0.22.0 // indirect + golang.org/x/tools v0.27.0 // indirect gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect ) diff --git a/examples/gasless/go.sum b/examples/gasless/go.sum index 43c9c8b..e22bb11 100644 --- a/examples/gasless/go.sum +++ b/examples/gasless/go.sum @@ -1,29 +1,31 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0= -github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= -github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs= -github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw= +github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo= +github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= +github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= +github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= -github.com/go-faster/errors v0.6.1 h1:nNIPOBkprlKzkThvS/0YaX8Zs9KewLCOSFQS5BU06FI= -github.com/go-faster/errors v0.6.1/go.mod h1:5MGV2/2T9yvlrbhe9pD9LO5Z/2zCSq2T8j+Jpi2LAyY= +github.com/go-faster/errors v0.7.1 h1:MkJTnDoEdi9pDabt1dpWf7AA8/BaSYZqibYyhZ20AYg= +github.com/go-faster/errors v0.7.1/go.mod h1:5ySTjWFiphBs07IKuiL69nxdfd5+fzh1u7FPGZP2quo= github.com/go-faster/jx v1.1.0 h1:ZsW3wD+snOdmTDy9eIVgQdjUpXRRV4rqW8NS3t+20bg= github.com/go-faster/jx v1.1.0/go.mod h1:vKDNikrKoyUmpzaJ0OkIkRQClNHFX/nF3dnTJZb3skg= github.com/go-faster/yaml v0.4.6 h1:lOK/EhI04gCpPgPhgt0bChS6bvw7G3WwI8xxVe0sw9I= github.com/go-faster/yaml v0.4.6/go.mod h1:390dRIvV4zbnO7qC9FGo6YYutc+wyyUSHBgbXL52eXk= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ= -github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= -github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4= -github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY= github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= +github.com/graze/go-throttled v0.3.1 h1:Mr9hMy0GXnbFlOWQl6pjNyn8T+9/LWIv1hJndNhs9mo= +github.com/graze/go-throttled v0.3.1/go.mod h1:OYBew5YhHxQqZGjoa7M8NQLIj+ztV+Iv5xCvzK1sQLg= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= @@ -35,8 +37,8 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae h1:7smdlrfdcZic4VfsGKD2ulWL804a4GVphr4s7WZxGiY= github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae/go.mod h1:hVoHR2EVESiICEMbg137etN/Lx+lSrHPTD39Z/uE+2s= -github.com/ogen-go/ogen v0.77.0 h1:yREPDg3cDuXkDyp7FPXdPEUz+azPZFUGKmYer8fJpmM= -github.com/ogen-go/ogen v0.77.0/go.mod h1:/bl+MubIppovr7F1fKAaDxzFF+oF2EiMtyVylyqDtQ8= +github.com/ogen-go/ogen v1.8.1 h1:7TZ+oIeLkcBiyl0qu0fHPrFUrGWDj3Fi/zKSWg2i2Tg= +github.com/ogen-go/ogen v1.8.1/go.mod h1:2ShRm6u/nXUHuwdVKv2SeaG8enBKPKAE3kSbHwwFh6o= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/r3labs/sse/v2 v2.10.0 h1:hFEkLLFY4LDifoHdiCN/LlGBAdVJYsANaLqNYa1l/v0= @@ -51,46 +53,48 @@ github.com/snksoft/crc v1.1.0 h1:HkLdI4taFlgGGG1KvsWMpz78PkOC9TkPVpTV/cuWn48= github.com/snksoft/crc v1.1.0/go.mod h1:5/gUOsgAm7OmIhb6WJzw7w5g2zfJi4FrHYgGPdshE+A= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/tonkeeper/tonapi-go v0.0.5 h1:Uac7aJScmM/4SU+80s9xKBH+XW5yxQ2iOsv3SsaWwB4= -github.com/tonkeeper/tonapi-go v0.0.5/go.mod h1:kKvamEj2vaaRxJIEP23NujwmrfrAeJjkZtRGchdFSj0= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/tonkeeper/tonapi-go v0.0.13 h1:rDMdwq0EdHOKR/KS55r8XErIDccP5CA5AXBrrhUH/rs= +github.com/tonkeeper/tonapi-go v0.0.13/go.mod h1:iGHl6iVxlvXnSusK0AH22yiv47UQU9yCxy7qAd4NYt4= github.com/tonkeeper/tongo v1.9.0 h1:yWPc13byc341mnKOBbPkBzGs9GxGdZ+ugMIBg+Q2pNk= github.com/tonkeeper/tongo v1.9.0/go.mod h1:MjgIgAytFarjCoVjMLjYEtpZNN1f2G/pnZhKjr28cWs= -go.opentelemetry.io/otel v1.19.0 h1:MuS/TNf4/j4IXsZuJegVzI1cwut7Qc00344rgH7p8bs= -go.opentelemetry.io/otel v1.19.0/go.mod h1:i0QyjOq3UPoTzff0PJB2N66fb4S0+rSbSB15/oyH9fY= -go.opentelemetry.io/otel/metric v1.19.0 h1:aTzpGtV0ar9wlV4Sna9sdJyII5jTVJEvKETPiOKwvpE= -go.opentelemetry.io/otel/metric v1.19.0/go.mod h1:L5rUsV9kM1IxCj1MmSdS+JQAcVm319EUrDVLrt7jqt8= -go.opentelemetry.io/otel/trace v1.19.0 h1:DFVQmlVbfVeOuBRrwdtaehRrWiL1JoVs9CPIQ1Dzxpg= -go.opentelemetry.io/otel/trace v1.19.0/go.mod h1:mfaSyvGyEJEI0nyV2I4qhNQnbBOUUmYZpYojqMnX2vo= -go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A= -go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4= +go.opentelemetry.io/otel v1.32.0 h1:WnBN+Xjcteh0zdk01SVqV55d/m62NJLJdIyb4y/WO5U= +go.opentelemetry.io/otel v1.32.0/go.mod h1:00DCVSB0RQcnzlwyTfqtxSm+DRr9hpYrHjNGiBHVQIg= +go.opentelemetry.io/otel/metric v1.32.0 h1:xV2umtmNcThh2/a/aCP+h64Xx5wsj8qqnkYZktzNa0M= +go.opentelemetry.io/otel/metric v1.32.0/go.mod h1:jH7CIbbK6SH2V2wE16W05BHCtIDzauciCRLoc/SyMv8= +go.opentelemetry.io/otel/trace v1.32.0 h1:WIC9mYrXf8TmY/EXuULKc8hR17vE+Hjv2cssQDe03fM= +go.opentelemetry.io/otel/trace v1.32.0/go.mod h1:+i4rkvCraA+tG6AzwloGaCtkx53Fa+L+V8e9a7YvhT8= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo= -go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA= -golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= +golang.org/x/crypto v0.35.0 h1:b15kiHdrGCHrP6LvwaQ3c03kgNhhiMgvlhxHQhmg2Xs= +golang.org/x/crypto v0.35.0/go.mod h1:dy7dXNW32cAb/6/PRuTNsix8T+vJAqvuIy5Bli/x0YQ= golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 h1:Di6/M8l0O2lCLc6VVRWhgCiApHV8MnQurBnFSHsQtNY= golang.org/x/exp v0.0.0-20230725093048-515e97ebf090/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= -golang.org/x/mod v0.13.0 h1:I/DsJXRlw/8l/0c24sM9yb0T4z9liZTduXvdAWYiysY= -golang.org/x/mod v0.13.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4= +golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= golang.org/x/net v0.0.0-20191116160921-f9c825593386/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= -golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= -golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ= -golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= +golang.org/x/net v0.36.0 h1:vWF2fRbw4qslQsQzgFqZff+BItCvGFQqKzKIzx1rmoA= +golang.org/x/net v0.36.0/go.mod h1:bFmbeoIPfrw4sMHNhb4J9f6+tPziuGjq7Jk/38fxi1I= +golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w= +golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= -golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc= +golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/tools v0.14.0 h1:jvNa2pY0M4r62jkRQ6RwEZZyPcymeL9XZMLBbV7U2nc= -golang.org/x/tools v0.14.0/go.mod h1:uYBEerGOWcJyEORxN+Ek8+TT266gXkNlHdJBwexUsBg= +golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM= +golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.27.0 h1:qEKojBykQkQ4EynWy4S8Weg69NumxKdn40Fce3uc/8o= +golang.org/x/tools v0.27.0/go.mod h1:sUi0ZgbwW9ZPAq26Ekut+weQPR5eIM6GQLQ1Yjm1H0Q= gopkg.in/cenkalti/backoff.v1 v1.1.0 h1:Arh75ttbsvlpVA7WtVpH4u9h6Zl46xuptxqLxPiSo4Y= gopkg.in/cenkalti/backoff.v1 v1.1.0/go.mod h1:J6Vskwqd+OMVJl8C33mmtxTBs2gyzfv7UDAkHu8BrjI= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/examples/gasless/main.go b/examples/gasless/main.go index d858b87..183f01f 100644 --- a/examples/gasless/main.go +++ b/examples/gasless/main.go @@ -49,7 +49,7 @@ func main() { // if you need to send lots of requests in parallel, // make sure you use a tonapi token. - tonapiCli, err := tonapi.New() + tonapiCli, err := tonapi.NewClient(tonapi.TonApiURL, &tonapi.Security{}) if err != nil { panic(err) } @@ -201,7 +201,7 @@ func main() { WalletPublicKey: hex.EncodeToString(publicKey), Boc: msgBoc, } - if err := tonapiCli.GaslessSend(context.Background(), &sendReq); err != nil { + if _, err = tonapiCli.GaslessSend(context.Background(), &sendReq); err != nil { panic(err) } fmt.Printf("A gasless transfer sent\n") diff --git a/examples/sse/go.mod b/examples/sse/go.mod index d3ad187..36f1510 100644 --- a/examples/sse/go.mod +++ b/examples/sse/go.mod @@ -1,41 +1,43 @@ module github.com/tonkeeper/tonapi-go/examples/sse -go 1.21.3 +go 1.22.0 -require github.com/tonkeeper/tonapi-go v0.0.3 +toolchain go1.23.0 + +require github.com/tonkeeper/tonapi-go v0.0.13 require ( - github.com/dlclark/regexp2 v1.10.0 // indirect - github.com/fatih/color v1.15.0 // indirect + github.com/dlclark/regexp2 v1.11.4 // indirect + github.com/fatih/color v1.18.0 // indirect github.com/ghodss/yaml v1.0.0 // indirect - github.com/go-faster/errors v0.6.1 // indirect + github.com/go-faster/errors v0.7.1 // indirect github.com/go-faster/jx v1.1.0 // indirect github.com/go-faster/yaml v0.4.6 // indirect - github.com/go-logr/logr v1.2.4 // indirect + github.com/go-logr/logr v1.4.2 // indirect github.com/go-logr/stdr v1.2.2 // indirect - github.com/google/uuid v1.4.0 // indirect + github.com/google/uuid v1.6.0 // indirect github.com/gorilla/websocket v1.5.1 // indirect github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-isatty v0.0.20 // indirect github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae // indirect - github.com/ogen-go/ogen v0.77.0 // indirect + github.com/ogen-go/ogen v1.8.1 // indirect github.com/r3labs/sse/v2 v2.10.0 // indirect github.com/segmentio/asm v1.2.0 // indirect github.com/snksoft/crc v1.1.0 // indirect - github.com/tonkeeper/tongo v1.4.1 // indirect - go.opentelemetry.io/otel v1.19.0 // indirect - go.opentelemetry.io/otel/metric v1.19.0 // indirect - go.opentelemetry.io/otel/trace v1.19.0 // indirect + github.com/tonkeeper/tongo v1.7.0 // indirect + go.opentelemetry.io/otel v1.32.0 // indirect + go.opentelemetry.io/otel/metric v1.32.0 // indirect + go.opentelemetry.io/otel/trace v1.32.0 // indirect go.uber.org/multierr v1.11.0 // indirect - go.uber.org/zap v1.26.0 // indirect - golang.org/x/crypto v0.14.0 // indirect + go.uber.org/zap v1.27.0 // indirect + golang.org/x/crypto v0.29.0 // indirect golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 // indirect - golang.org/x/mod v0.13.0 // indirect - golang.org/x/net v0.17.0 // indirect - golang.org/x/sync v0.4.0 // indirect - golang.org/x/sys v0.13.0 // indirect - golang.org/x/text v0.13.0 // indirect - golang.org/x/tools v0.14.0 // indirect + golang.org/x/mod v0.22.0 // indirect + golang.org/x/net v0.31.0 // indirect + golang.org/x/sync v0.9.0 // indirect + golang.org/x/sys v0.27.0 // indirect + golang.org/x/text v0.20.0 // indirect + golang.org/x/tools v0.27.0 // indirect gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect ) diff --git a/examples/sse/go.sum b/examples/sse/go.sum index 3f01d94..bc12038 100644 --- a/examples/sse/go.sum +++ b/examples/sse/go.sum @@ -1,29 +1,31 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0= -github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= -github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs= -github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw= +github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo= +github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= +github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= +github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= -github.com/go-faster/errors v0.6.1 h1:nNIPOBkprlKzkThvS/0YaX8Zs9KewLCOSFQS5BU06FI= -github.com/go-faster/errors v0.6.1/go.mod h1:5MGV2/2T9yvlrbhe9pD9LO5Z/2zCSq2T8j+Jpi2LAyY= +github.com/go-faster/errors v0.7.1 h1:MkJTnDoEdi9pDabt1dpWf7AA8/BaSYZqibYyhZ20AYg= +github.com/go-faster/errors v0.7.1/go.mod h1:5ySTjWFiphBs07IKuiL69nxdfd5+fzh1u7FPGZP2quo= github.com/go-faster/jx v1.1.0 h1:ZsW3wD+snOdmTDy9eIVgQdjUpXRRV4rqW8NS3t+20bg= github.com/go-faster/jx v1.1.0/go.mod h1:vKDNikrKoyUmpzaJ0OkIkRQClNHFX/nF3dnTJZb3skg= github.com/go-faster/yaml v0.4.6 h1:lOK/EhI04gCpPgPhgt0bChS6bvw7G3WwI8xxVe0sw9I= github.com/go-faster/yaml v0.4.6/go.mod h1:390dRIvV4zbnO7qC9FGo6YYutc+wyyUSHBgbXL52eXk= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ= -github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= -github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4= -github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY= github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= +github.com/graze/go-throttled v0.3.1 h1:Mr9hMy0GXnbFlOWQl6pjNyn8T+9/LWIv1hJndNhs9mo= +github.com/graze/go-throttled v0.3.1/go.mod h1:OYBew5YhHxQqZGjoa7M8NQLIj+ztV+Iv5xCvzK1sQLg= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= @@ -35,8 +37,8 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae h1:7smdlrfdcZic4VfsGKD2ulWL804a4GVphr4s7WZxGiY= github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae/go.mod h1:hVoHR2EVESiICEMbg137etN/Lx+lSrHPTD39Z/uE+2s= -github.com/ogen-go/ogen v0.77.0 h1:yREPDg3cDuXkDyp7FPXdPEUz+azPZFUGKmYer8fJpmM= -github.com/ogen-go/ogen v0.77.0/go.mod h1:/bl+MubIppovr7F1fKAaDxzFF+oF2EiMtyVylyqDtQ8= +github.com/ogen-go/ogen v1.8.1 h1:7TZ+oIeLkcBiyl0qu0fHPrFUrGWDj3Fi/zKSWg2i2Tg= +github.com/ogen-go/ogen v1.8.1/go.mod h1:2ShRm6u/nXUHuwdVKv2SeaG8enBKPKAE3kSbHwwFh6o= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/r3labs/sse/v2 v2.10.0 h1:hFEkLLFY4LDifoHdiCN/LlGBAdVJYsANaLqNYa1l/v0= @@ -49,46 +51,48 @@ github.com/snksoft/crc v1.1.0 h1:HkLdI4taFlgGGG1KvsWMpz78PkOC9TkPVpTV/cuWn48= github.com/snksoft/crc v1.1.0/go.mod h1:5/gUOsgAm7OmIhb6WJzw7w5g2zfJi4FrHYgGPdshE+A= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/tonkeeper/tonapi-go v0.0.3 h1:T0C40m4OnGJmR17ijRBFDBqlJm3IktjP3JOi8VRXZWk= -github.com/tonkeeper/tonapi-go v0.0.3/go.mod h1:2n+LizNjCQbCZhvVSooKGnzxAgdIrgePsh6Kgea0NPY= -github.com/tonkeeper/tongo v1.4.1 h1:QMIya/ongFuOyHgVOFmHF+Cu4nt23KumPRLApmp90zE= -github.com/tonkeeper/tongo v1.4.1/go.mod h1:LdOBjpUz6vLp1EdX3E0XLNks9YI5XMSqaQahfOMrBEY= -go.opentelemetry.io/otel v1.19.0 h1:MuS/TNf4/j4IXsZuJegVzI1cwut7Qc00344rgH7p8bs= -go.opentelemetry.io/otel v1.19.0/go.mod h1:i0QyjOq3UPoTzff0PJB2N66fb4S0+rSbSB15/oyH9fY= -go.opentelemetry.io/otel/metric v1.19.0 h1:aTzpGtV0ar9wlV4Sna9sdJyII5jTVJEvKETPiOKwvpE= -go.opentelemetry.io/otel/metric v1.19.0/go.mod h1:L5rUsV9kM1IxCj1MmSdS+JQAcVm319EUrDVLrt7jqt8= -go.opentelemetry.io/otel/trace v1.19.0 h1:DFVQmlVbfVeOuBRrwdtaehRrWiL1JoVs9CPIQ1Dzxpg= -go.opentelemetry.io/otel/trace v1.19.0/go.mod h1:mfaSyvGyEJEI0nyV2I4qhNQnbBOUUmYZpYojqMnX2vo= -go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A= -go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/tonkeeper/tonapi-go v0.0.13 h1:rDMdwq0EdHOKR/KS55r8XErIDccP5CA5AXBrrhUH/rs= +github.com/tonkeeper/tonapi-go v0.0.13/go.mod h1:iGHl6iVxlvXnSusK0AH22yiv47UQU9yCxy7qAd4NYt4= +github.com/tonkeeper/tongo v1.7.0 h1:ldQkcOZU6FqE1iuwE3UYxXGkmGnu9XlZSaix4qXG3Wk= +github.com/tonkeeper/tongo v1.7.0/go.mod h1:MjgIgAytFarjCoVjMLjYEtpZNN1f2G/pnZhKjr28cWs= +go.opentelemetry.io/otel v1.32.0 h1:WnBN+Xjcteh0zdk01SVqV55d/m62NJLJdIyb4y/WO5U= +go.opentelemetry.io/otel v1.32.0/go.mod h1:00DCVSB0RQcnzlwyTfqtxSm+DRr9hpYrHjNGiBHVQIg= +go.opentelemetry.io/otel/metric v1.32.0 h1:xV2umtmNcThh2/a/aCP+h64Xx5wsj8qqnkYZktzNa0M= +go.opentelemetry.io/otel/metric v1.32.0/go.mod h1:jH7CIbbK6SH2V2wE16W05BHCtIDzauciCRLoc/SyMv8= +go.opentelemetry.io/otel/trace v1.32.0 h1:WIC9mYrXf8TmY/EXuULKc8hR17vE+Hjv2cssQDe03fM= +go.opentelemetry.io/otel/trace v1.32.0/go.mod h1:+i4rkvCraA+tG6AzwloGaCtkx53Fa+L+V8e9a7YvhT8= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo= -go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.14.0 h1:wBqGXzWJW6m1XrIKlAH0Hs1JJ7+9KBwnIO8v66Q9cHc= -golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4= +golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ= +golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg= golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 h1:Di6/M8l0O2lCLc6VVRWhgCiApHV8MnQurBnFSHsQtNY= golang.org/x/exp v0.0.0-20230725093048-515e97ebf090/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= -golang.org/x/mod v0.13.0 h1:I/DsJXRlw/8l/0c24sM9yb0T4z9liZTduXvdAWYiysY= -golang.org/x/mod v0.13.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4= +golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= golang.org/x/net v0.0.0-20191116160921-f9c825593386/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM= -golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE= -golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ= -golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= +golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo= +golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM= +golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ= +golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.13.0 h1:Af8nKPmuFypiUBjVoU9V20FiaFXOcuZI21p0ycVYYGE= -golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s= +golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k= -golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= -golang.org/x/tools v0.14.0 h1:jvNa2pY0M4r62jkRQ6RwEZZyPcymeL9XZMLBbV7U2nc= -golang.org/x/tools v0.14.0/go.mod h1:uYBEerGOWcJyEORxN+Ek8+TT266gXkNlHdJBwexUsBg= +golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug= +golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.27.0 h1:qEKojBykQkQ4EynWy4S8Weg69NumxKdn40Fce3uc/8o= +golang.org/x/tools v0.27.0/go.mod h1:sUi0ZgbwW9ZPAq26Ekut+weQPR5eIM6GQLQ1Yjm1H0Q= gopkg.in/cenkalti/backoff.v1 v1.1.0 h1:Arh75ttbsvlpVA7WtVpH4u9h6Zl46xuptxqLxPiSo4Y= gopkg.in/cenkalti/backoff.v1 v1.1.0/go.mod h1:J6Vskwqd+OMVJl8C33mmtxTBs2gyzfv7UDAkHu8BrjI= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/examples/tonapi-sdk/go.mod b/examples/tonapi-sdk/go.mod index 2286f0d..f05420e 100644 --- a/examples/tonapi-sdk/go.mod +++ b/examples/tonapi-sdk/go.mod @@ -1,41 +1,43 @@ module github.com/tonkeeper/tonapi-go/examples/tonapi-sdk -go 1.21.3 +go 1.22.0 -require github.com/tonkeeper/tonapi-go v0.0.2 +toolchain go1.23.0 + +require github.com/tonkeeper/tonapi-go v0.0.13 require ( - github.com/dlclark/regexp2 v1.10.0 // indirect - github.com/fatih/color v1.15.0 // indirect + github.com/dlclark/regexp2 v1.11.4 // indirect + github.com/fatih/color v1.18.0 // indirect github.com/ghodss/yaml v1.0.0 // indirect - github.com/go-faster/errors v0.6.1 // indirect + github.com/go-faster/errors v0.7.1 // indirect github.com/go-faster/jx v1.1.0 // indirect github.com/go-faster/yaml v0.4.6 // indirect - github.com/go-logr/logr v1.2.4 // indirect + github.com/go-logr/logr v1.4.2 // indirect github.com/go-logr/stdr v1.2.2 // indirect - github.com/google/uuid v1.4.0 // indirect + github.com/google/uuid v1.6.0 // indirect github.com/gorilla/websocket v1.5.1 // indirect github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-isatty v0.0.20 // indirect github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae // indirect - github.com/ogen-go/ogen v0.77.0 // indirect + github.com/ogen-go/ogen v1.8.1 // indirect github.com/r3labs/sse/v2 v2.10.0 // indirect github.com/segmentio/asm v1.2.0 // indirect github.com/snksoft/crc v1.1.0 // indirect github.com/tonkeeper/tongo v1.7.0 // indirect - go.opentelemetry.io/otel v1.19.0 // indirect - go.opentelemetry.io/otel/metric v1.19.0 // indirect - go.opentelemetry.io/otel/trace v1.19.0 // indirect + go.opentelemetry.io/otel v1.32.0 // indirect + go.opentelemetry.io/otel/metric v1.32.0 // indirect + go.opentelemetry.io/otel/trace v1.32.0 // indirect go.uber.org/multierr v1.11.0 // indirect - go.uber.org/zap v1.26.0 // indirect - golang.org/x/crypto v0.17.0 // indirect + go.uber.org/zap v1.27.0 // indirect + golang.org/x/crypto v0.29.0 // indirect golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 // indirect - golang.org/x/mod v0.13.0 // indirect - golang.org/x/net v0.17.0 // indirect - golang.org/x/sync v0.4.0 // indirect - golang.org/x/sys v0.15.0 // indirect - golang.org/x/text v0.14.0 // indirect - golang.org/x/tools v0.14.0 // indirect + golang.org/x/mod v0.22.0 // indirect + golang.org/x/net v0.31.0 // indirect + golang.org/x/sync v0.9.0 // indirect + golang.org/x/sys v0.27.0 // indirect + golang.org/x/text v0.20.0 // indirect + golang.org/x/tools v0.27.0 // indirect gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect ) diff --git a/examples/tonapi-sdk/go.sum b/examples/tonapi-sdk/go.sum index ea069a9..bc12038 100644 --- a/examples/tonapi-sdk/go.sum +++ b/examples/tonapi-sdk/go.sum @@ -1,29 +1,31 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0= -github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= -github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs= -github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw= +github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo= +github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= +github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= +github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= -github.com/go-faster/errors v0.6.1 h1:nNIPOBkprlKzkThvS/0YaX8Zs9KewLCOSFQS5BU06FI= -github.com/go-faster/errors v0.6.1/go.mod h1:5MGV2/2T9yvlrbhe9pD9LO5Z/2zCSq2T8j+Jpi2LAyY= +github.com/go-faster/errors v0.7.1 h1:MkJTnDoEdi9pDabt1dpWf7AA8/BaSYZqibYyhZ20AYg= +github.com/go-faster/errors v0.7.1/go.mod h1:5ySTjWFiphBs07IKuiL69nxdfd5+fzh1u7FPGZP2quo= github.com/go-faster/jx v1.1.0 h1:ZsW3wD+snOdmTDy9eIVgQdjUpXRRV4rqW8NS3t+20bg= github.com/go-faster/jx v1.1.0/go.mod h1:vKDNikrKoyUmpzaJ0OkIkRQClNHFX/nF3dnTJZb3skg= github.com/go-faster/yaml v0.4.6 h1:lOK/EhI04gCpPgPhgt0bChS6bvw7G3WwI8xxVe0sw9I= github.com/go-faster/yaml v0.4.6/go.mod h1:390dRIvV4zbnO7qC9FGo6YYutc+wyyUSHBgbXL52eXk= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ= -github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= -github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4= -github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY= github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= +github.com/graze/go-throttled v0.3.1 h1:Mr9hMy0GXnbFlOWQl6pjNyn8T+9/LWIv1hJndNhs9mo= +github.com/graze/go-throttled v0.3.1/go.mod h1:OYBew5YhHxQqZGjoa7M8NQLIj+ztV+Iv5xCvzK1sQLg= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= @@ -35,8 +37,8 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae h1:7smdlrfdcZic4VfsGKD2ulWL804a4GVphr4s7WZxGiY= github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae/go.mod h1:hVoHR2EVESiICEMbg137etN/Lx+lSrHPTD39Z/uE+2s= -github.com/ogen-go/ogen v0.77.0 h1:yREPDg3cDuXkDyp7FPXdPEUz+azPZFUGKmYer8fJpmM= -github.com/ogen-go/ogen v0.77.0/go.mod h1:/bl+MubIppovr7F1fKAaDxzFF+oF2EiMtyVylyqDtQ8= +github.com/ogen-go/ogen v1.8.1 h1:7TZ+oIeLkcBiyl0qu0fHPrFUrGWDj3Fi/zKSWg2i2Tg= +github.com/ogen-go/ogen v1.8.1/go.mod h1:2ShRm6u/nXUHuwdVKv2SeaG8enBKPKAE3kSbHwwFh6o= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/r3labs/sse/v2 v2.10.0 h1:hFEkLLFY4LDifoHdiCN/LlGBAdVJYsANaLqNYa1l/v0= @@ -49,46 +51,48 @@ github.com/snksoft/crc v1.1.0 h1:HkLdI4taFlgGGG1KvsWMpz78PkOC9TkPVpTV/cuWn48= github.com/snksoft/crc v1.1.0/go.mod h1:5/gUOsgAm7OmIhb6WJzw7w5g2zfJi4FrHYgGPdshE+A= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/tonkeeper/tonapi-go v0.0.2 h1:Bnl+u7POYtiFbgm4fhIxzynnGJWJxWkNew9lvGABcZA= -github.com/tonkeeper/tonapi-go v0.0.2/go.mod h1:2n+LizNjCQbCZhvVSooKGnzxAgdIrgePsh6Kgea0NPY= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/tonkeeper/tonapi-go v0.0.13 h1:rDMdwq0EdHOKR/KS55r8XErIDccP5CA5AXBrrhUH/rs= +github.com/tonkeeper/tonapi-go v0.0.13/go.mod h1:iGHl6iVxlvXnSusK0AH22yiv47UQU9yCxy7qAd4NYt4= github.com/tonkeeper/tongo v1.7.0 h1:ldQkcOZU6FqE1iuwE3UYxXGkmGnu9XlZSaix4qXG3Wk= github.com/tonkeeper/tongo v1.7.0/go.mod h1:MjgIgAytFarjCoVjMLjYEtpZNN1f2G/pnZhKjr28cWs= -go.opentelemetry.io/otel v1.19.0 h1:MuS/TNf4/j4IXsZuJegVzI1cwut7Qc00344rgH7p8bs= -go.opentelemetry.io/otel v1.19.0/go.mod h1:i0QyjOq3UPoTzff0PJB2N66fb4S0+rSbSB15/oyH9fY= -go.opentelemetry.io/otel/metric v1.19.0 h1:aTzpGtV0ar9wlV4Sna9sdJyII5jTVJEvKETPiOKwvpE= -go.opentelemetry.io/otel/metric v1.19.0/go.mod h1:L5rUsV9kM1IxCj1MmSdS+JQAcVm319EUrDVLrt7jqt8= -go.opentelemetry.io/otel/trace v1.19.0 h1:DFVQmlVbfVeOuBRrwdtaehRrWiL1JoVs9CPIQ1Dzxpg= -go.opentelemetry.io/otel/trace v1.19.0/go.mod h1:mfaSyvGyEJEI0nyV2I4qhNQnbBOUUmYZpYojqMnX2vo= -go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A= -go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4= +go.opentelemetry.io/otel v1.32.0 h1:WnBN+Xjcteh0zdk01SVqV55d/m62NJLJdIyb4y/WO5U= +go.opentelemetry.io/otel v1.32.0/go.mod h1:00DCVSB0RQcnzlwyTfqtxSm+DRr9hpYrHjNGiBHVQIg= +go.opentelemetry.io/otel/metric v1.32.0 h1:xV2umtmNcThh2/a/aCP+h64Xx5wsj8qqnkYZktzNa0M= +go.opentelemetry.io/otel/metric v1.32.0/go.mod h1:jH7CIbbK6SH2V2wE16W05BHCtIDzauciCRLoc/SyMv8= +go.opentelemetry.io/otel/trace v1.32.0 h1:WIC9mYrXf8TmY/EXuULKc8hR17vE+Hjv2cssQDe03fM= +go.opentelemetry.io/otel/trace v1.32.0/go.mod h1:+i4rkvCraA+tG6AzwloGaCtkx53Fa+L+V8e9a7YvhT8= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo= -go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k= -golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= +golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ= +golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg= golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 h1:Di6/M8l0O2lCLc6VVRWhgCiApHV8MnQurBnFSHsQtNY= golang.org/x/exp v0.0.0-20230725093048-515e97ebf090/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= -golang.org/x/mod v0.13.0 h1:I/DsJXRlw/8l/0c24sM9yb0T4z9liZTduXvdAWYiysY= -golang.org/x/mod v0.13.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4= +golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= golang.org/x/net v0.0.0-20191116160921-f9c825593386/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.17.0 h1:pVaXccu2ozPjCXewfr1S7xza/zcXTity9cCdXQYSjIM= -golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE= -golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ= -golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= +golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo= +golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM= +golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ= +golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.15.0 h1:h48lPFYpsTvQJZF4EKyI4aLHaev3CxivZmv7yZig9pc= -golang.org/x/sys v0.15.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s= +golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/tools v0.14.0 h1:jvNa2pY0M4r62jkRQ6RwEZZyPcymeL9XZMLBbV7U2nc= -golang.org/x/tools v0.14.0/go.mod h1:uYBEerGOWcJyEORxN+Ek8+TT266gXkNlHdJBwexUsBg= +golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug= +golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.27.0 h1:qEKojBykQkQ4EynWy4S8Weg69NumxKdn40Fce3uc/8o= +golang.org/x/tools v0.27.0/go.mod h1:sUi0ZgbwW9ZPAq26Ekut+weQPR5eIM6GQLQ1Yjm1H0Q= gopkg.in/cenkalti/backoff.v1 v1.1.0 h1:Arh75ttbsvlpVA7WtVpH4u9h6Zl46xuptxqLxPiSo4Y= gopkg.in/cenkalti/backoff.v1 v1.1.0/go.mod h1:J6Vskwqd+OMVJl8C33mmtxTBs2gyzfv7UDAkHu8BrjI= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/examples/tonapi-sdk/main.go b/examples/tonapi-sdk/main.go index dcf7683..2b740f4 100644 --- a/examples/tonapi-sdk/main.go +++ b/examples/tonapi-sdk/main.go @@ -11,7 +11,7 @@ import ( const myAccount = "EQBszTJahYw3lpP64ryqscKQaDGk4QpsO7RO6LYVvKHSINS0" func printAccountInformation(myAccount string) error { - client, err := tonapi.New() + client, err := tonapi.NewClient(tonapi.TonApiURL, &tonapi.Security{}) if err != nil { return err } diff --git a/examples/websocket/go.mod b/examples/websocket/go.mod index e916673..010c974 100644 --- a/examples/websocket/go.mod +++ b/examples/websocket/go.mod @@ -1,41 +1,43 @@ module github.com/tonkeeper/tonapi-go/examples/websocket -go 1.21.3 +go 1.22.0 -require github.com/tonkeeper/tonapi-go v0.0.3 +toolchain go1.23.0 + +require github.com/tonkeeper/tonapi-go v0.0.13 require ( - github.com/dlclark/regexp2 v1.10.0 // indirect - github.com/fatih/color v1.15.0 // indirect + github.com/dlclark/regexp2 v1.11.4 // indirect + github.com/fatih/color v1.18.0 // indirect github.com/ghodss/yaml v1.0.0 // indirect - github.com/go-faster/errors v0.6.1 // indirect + github.com/go-faster/errors v0.7.1 // indirect github.com/go-faster/jx v1.1.0 // indirect github.com/go-faster/yaml v0.4.6 // indirect - github.com/go-logr/logr v1.2.4 // indirect + github.com/go-logr/logr v1.4.2 // indirect github.com/go-logr/stdr v1.2.2 // indirect - github.com/google/uuid v1.4.0 // indirect + github.com/google/uuid v1.6.0 // indirect github.com/gorilla/websocket v1.5.1 // indirect github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-isatty v0.0.20 // indirect github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae // indirect - github.com/ogen-go/ogen v0.77.0 // indirect + github.com/ogen-go/ogen v1.8.1 // indirect github.com/r3labs/sse/v2 v2.10.0 // indirect github.com/segmentio/asm v1.2.0 // indirect github.com/snksoft/crc v1.1.0 // indirect - github.com/tonkeeper/tongo v1.4.1 // indirect - go.opentelemetry.io/otel v1.19.0 // indirect - go.opentelemetry.io/otel/metric v1.19.0 // indirect - go.opentelemetry.io/otel/trace v1.19.0 // indirect + github.com/tonkeeper/tongo v1.7.0 // indirect + go.opentelemetry.io/otel v1.32.0 // indirect + go.opentelemetry.io/otel/metric v1.32.0 // indirect + go.opentelemetry.io/otel/trace v1.32.0 // indirect go.uber.org/multierr v1.11.0 // indirect - go.uber.org/zap v1.26.0 // indirect - golang.org/x/crypto v0.21.0 // indirect + go.uber.org/zap v1.27.0 // indirect + golang.org/x/crypto v0.29.0 // indirect golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 // indirect - golang.org/x/mod v0.13.0 // indirect - golang.org/x/net v0.23.0 // indirect - golang.org/x/sync v0.4.0 // indirect - golang.org/x/sys v0.18.0 // indirect - golang.org/x/text v0.14.0 // indirect - golang.org/x/tools v0.14.0 // indirect + golang.org/x/mod v0.22.0 // indirect + golang.org/x/net v0.31.0 // indirect + golang.org/x/sync v0.9.0 // indirect + golang.org/x/sys v0.27.0 // indirect + golang.org/x/text v0.20.0 // indirect + golang.org/x/tools v0.27.0 // indirect gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect ) diff --git a/examples/websocket/go.sum b/examples/websocket/go.sum index de83c40..bc12038 100644 --- a/examples/websocket/go.sum +++ b/examples/websocket/go.sum @@ -1,29 +1,31 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0= -github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= -github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs= -github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw= +github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo= +github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= +github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= +github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= -github.com/go-faster/errors v0.6.1 h1:nNIPOBkprlKzkThvS/0YaX8Zs9KewLCOSFQS5BU06FI= -github.com/go-faster/errors v0.6.1/go.mod h1:5MGV2/2T9yvlrbhe9pD9LO5Z/2zCSq2T8j+Jpi2LAyY= +github.com/go-faster/errors v0.7.1 h1:MkJTnDoEdi9pDabt1dpWf7AA8/BaSYZqibYyhZ20AYg= +github.com/go-faster/errors v0.7.1/go.mod h1:5ySTjWFiphBs07IKuiL69nxdfd5+fzh1u7FPGZP2quo= github.com/go-faster/jx v1.1.0 h1:ZsW3wD+snOdmTDy9eIVgQdjUpXRRV4rqW8NS3t+20bg= github.com/go-faster/jx v1.1.0/go.mod h1:vKDNikrKoyUmpzaJ0OkIkRQClNHFX/nF3dnTJZb3skg= github.com/go-faster/yaml v0.4.6 h1:lOK/EhI04gCpPgPhgt0bChS6bvw7G3WwI8xxVe0sw9I= github.com/go-faster/yaml v0.4.6/go.mod h1:390dRIvV4zbnO7qC9FGo6YYutc+wyyUSHBgbXL52eXk= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ= -github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= -github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4= -github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY= github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= +github.com/graze/go-throttled v0.3.1 h1:Mr9hMy0GXnbFlOWQl6pjNyn8T+9/LWIv1hJndNhs9mo= +github.com/graze/go-throttled v0.3.1/go.mod h1:OYBew5YhHxQqZGjoa7M8NQLIj+ztV+Iv5xCvzK1sQLg= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= @@ -35,8 +37,8 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae h1:7smdlrfdcZic4VfsGKD2ulWL804a4GVphr4s7WZxGiY= github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae/go.mod h1:hVoHR2EVESiICEMbg137etN/Lx+lSrHPTD39Z/uE+2s= -github.com/ogen-go/ogen v0.77.0 h1:yREPDg3cDuXkDyp7FPXdPEUz+azPZFUGKmYer8fJpmM= -github.com/ogen-go/ogen v0.77.0/go.mod h1:/bl+MubIppovr7F1fKAaDxzFF+oF2EiMtyVylyqDtQ8= +github.com/ogen-go/ogen v1.8.1 h1:7TZ+oIeLkcBiyl0qu0fHPrFUrGWDj3Fi/zKSWg2i2Tg= +github.com/ogen-go/ogen v1.8.1/go.mod h1:2ShRm6u/nXUHuwdVKv2SeaG8enBKPKAE3kSbHwwFh6o= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/r3labs/sse/v2 v2.10.0 h1:hFEkLLFY4LDifoHdiCN/LlGBAdVJYsANaLqNYa1l/v0= @@ -49,46 +51,48 @@ github.com/snksoft/crc v1.1.0 h1:HkLdI4taFlgGGG1KvsWMpz78PkOC9TkPVpTV/cuWn48= github.com/snksoft/crc v1.1.0/go.mod h1:5/gUOsgAm7OmIhb6WJzw7w5g2zfJi4FrHYgGPdshE+A= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= -github.com/tonkeeper/tonapi-go v0.0.3 h1:T0C40m4OnGJmR17ijRBFDBqlJm3IktjP3JOi8VRXZWk= -github.com/tonkeeper/tonapi-go v0.0.3/go.mod h1:2n+LizNjCQbCZhvVSooKGnzxAgdIrgePsh6Kgea0NPY= -github.com/tonkeeper/tongo v1.4.1 h1:QMIya/ongFuOyHgVOFmHF+Cu4nt23KumPRLApmp90zE= -github.com/tonkeeper/tongo v1.4.1/go.mod h1:LdOBjpUz6vLp1EdX3E0XLNks9YI5XMSqaQahfOMrBEY= -go.opentelemetry.io/otel v1.19.0 h1:MuS/TNf4/j4IXsZuJegVzI1cwut7Qc00344rgH7p8bs= -go.opentelemetry.io/otel v1.19.0/go.mod h1:i0QyjOq3UPoTzff0PJB2N66fb4S0+rSbSB15/oyH9fY= -go.opentelemetry.io/otel/metric v1.19.0 h1:aTzpGtV0ar9wlV4Sna9sdJyII5jTVJEvKETPiOKwvpE= -go.opentelemetry.io/otel/metric v1.19.0/go.mod h1:L5rUsV9kM1IxCj1MmSdS+JQAcVm319EUrDVLrt7jqt8= -go.opentelemetry.io/otel/trace v1.19.0 h1:DFVQmlVbfVeOuBRrwdtaehRrWiL1JoVs9CPIQ1Dzxpg= -go.opentelemetry.io/otel/trace v1.19.0/go.mod h1:mfaSyvGyEJEI0nyV2I4qhNQnbBOUUmYZpYojqMnX2vo= -go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A= -go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/tonkeeper/tonapi-go v0.0.13 h1:rDMdwq0EdHOKR/KS55r8XErIDccP5CA5AXBrrhUH/rs= +github.com/tonkeeper/tonapi-go v0.0.13/go.mod h1:iGHl6iVxlvXnSusK0AH22yiv47UQU9yCxy7qAd4NYt4= +github.com/tonkeeper/tongo v1.7.0 h1:ldQkcOZU6FqE1iuwE3UYxXGkmGnu9XlZSaix4qXG3Wk= +github.com/tonkeeper/tongo v1.7.0/go.mod h1:MjgIgAytFarjCoVjMLjYEtpZNN1f2G/pnZhKjr28cWs= +go.opentelemetry.io/otel v1.32.0 h1:WnBN+Xjcteh0zdk01SVqV55d/m62NJLJdIyb4y/WO5U= +go.opentelemetry.io/otel v1.32.0/go.mod h1:00DCVSB0RQcnzlwyTfqtxSm+DRr9hpYrHjNGiBHVQIg= +go.opentelemetry.io/otel/metric v1.32.0 h1:xV2umtmNcThh2/a/aCP+h64Xx5wsj8qqnkYZktzNa0M= +go.opentelemetry.io/otel/metric v1.32.0/go.mod h1:jH7CIbbK6SH2V2wE16W05BHCtIDzauciCRLoc/SyMv8= +go.opentelemetry.io/otel/trace v1.32.0 h1:WIC9mYrXf8TmY/EXuULKc8hR17vE+Hjv2cssQDe03fM= +go.opentelemetry.io/otel/trace v1.32.0/go.mod h1:+i4rkvCraA+tG6AzwloGaCtkx53Fa+L+V8e9a7YvhT8= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo= -go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA= -golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= +golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ= +golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg= golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 h1:Di6/M8l0O2lCLc6VVRWhgCiApHV8MnQurBnFSHsQtNY= golang.org/x/exp v0.0.0-20230725093048-515e97ebf090/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= -golang.org/x/mod v0.13.0 h1:I/DsJXRlw/8l/0c24sM9yb0T4z9liZTduXvdAWYiysY= -golang.org/x/mod v0.13.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4= +golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= golang.org/x/net v0.0.0-20191116160921-f9c825593386/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= -golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= -golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ= -golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= +golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo= +golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM= +golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ= +golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= -golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s= +golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/tools v0.14.0 h1:jvNa2pY0M4r62jkRQ6RwEZZyPcymeL9XZMLBbV7U2nc= -golang.org/x/tools v0.14.0/go.mod h1:uYBEerGOWcJyEORxN+Ek8+TT266gXkNlHdJBwexUsBg= +golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug= +golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.27.0 h1:qEKojBykQkQ4EynWy4S8Weg69NumxKdn40Fce3uc/8o= +golang.org/x/tools v0.27.0/go.mod h1:sUi0ZgbwW9ZPAq26Ekut+weQPR5eIM6GQLQ1Yjm1H0Q= gopkg.in/cenkalti/backoff.v1 v1.1.0 h1:Arh75ttbsvlpVA7WtVpH4u9h6Zl46xuptxqLxPiSo4Y= gopkg.in/cenkalti/backoff.v1 v1.1.0/go.mod h1:J6Vskwqd+OMVJl8C33mmtxTBs2gyzfv7UDAkHu8BrjI= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/gen.go b/gen.go index be6c509..b6cead9 100644 --- a/gen.go +++ b/gen.go @@ -1,3 +1,3 @@ package tonapi -//go:generate go run github.com/ogen-go/ogen/cmd/ogen -convenient-errors -clean -no-server -package tonapi -target . api/openapi.yml +//go:generate go run github.com/ogen-go/ogen/cmd/ogen -clean -package tonapi -target . api/openapi.yml diff --git a/go.mod b/go.mod index 6f63bd0..05b6426 100644 --- a/go.mod +++ b/go.mod @@ -1,30 +1,34 @@ module github.com/tonkeeper/tonapi-go -go 1.21.3 +go 1.22.0 + +toolchain go1.23.0 require ( - github.com/go-faster/errors v0.6.1 + github.com/go-faster/errors v0.7.1 github.com/go-faster/jx v1.1.0 github.com/gorilla/websocket v1.5.1 - github.com/ogen-go/ogen v0.77.0 + github.com/graze/go-throttled v0.3.1 + github.com/ogen-go/ogen v1.8.1 github.com/r3labs/sse/v2 v2.10.0 - github.com/stretchr/testify v1.8.4 + github.com/stretchr/testify v1.10.0 github.com/tonkeeper/tongo v1.7.0 - go.opentelemetry.io/otel v1.19.0 - go.opentelemetry.io/otel/metric v1.19.0 - go.opentelemetry.io/otel/trace v1.19.0 - golang.org/x/sync v0.4.0 + go.opentelemetry.io/otel v1.32.0 + go.opentelemetry.io/otel/metric v1.32.0 + go.opentelemetry.io/otel/trace v1.32.0 + golang.org/x/sync v0.9.0 + golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 ) require ( github.com/davecgh/go-spew v1.1.1 // indirect - github.com/dlclark/regexp2 v1.10.0 // indirect - github.com/fatih/color v1.15.0 // indirect + github.com/dlclark/regexp2 v1.11.4 // indirect + github.com/fatih/color v1.18.0 // indirect github.com/ghodss/yaml v1.0.0 // indirect github.com/go-faster/yaml v0.4.6 // indirect - github.com/go-logr/logr v1.2.4 // indirect + github.com/go-logr/logr v1.4.2 // indirect github.com/go-logr/stdr v1.2.2 // indirect - github.com/google/uuid v1.4.0 // indirect + github.com/google/uuid v1.6.0 // indirect github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-isatty v0.0.20 // indirect github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae // indirect @@ -32,14 +36,14 @@ require ( github.com/segmentio/asm v1.2.0 // indirect github.com/snksoft/crc v1.1.0 // indirect go.uber.org/multierr v1.11.0 // indirect - go.uber.org/zap v1.26.0 // indirect - golang.org/x/crypto v0.21.0 // indirect + go.uber.org/zap v1.27.0 // indirect + golang.org/x/crypto v0.29.0 // indirect golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 // indirect - golang.org/x/mod v0.13.0 // indirect - golang.org/x/net v0.23.0 // indirect - golang.org/x/sys v0.18.0 // indirect - golang.org/x/text v0.14.0 // indirect - golang.org/x/tools v0.14.0 // indirect + golang.org/x/mod v0.22.0 // indirect + golang.org/x/net v0.31.0 // indirect + golang.org/x/sys v0.27.0 // indirect + golang.org/x/text v0.20.0 // indirect + golang.org/x/tools v0.27.0 // indirect gopkg.in/cenkalti/backoff.v1 v1.1.0 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect diff --git a/go.sum b/go.sum index 928a92d..b434ab2 100644 --- a/go.sum +++ b/go.sum @@ -1,29 +1,31 @@ github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/dlclark/regexp2 v1.10.0 h1:+/GIL799phkJqYW+3YbOd8LCcbHzT0Pbo8zl70MHsq0= -github.com/dlclark/regexp2 v1.10.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= -github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs= -github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw= +github.com/dlclark/regexp2 v1.11.4 h1:rPYF9/LECdNymJufQKmri9gV604RvvABwgOA8un7yAo= +github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= +github.com/fatih/color v1.18.0 h1:S8gINlzdQ840/4pfAwic/ZE0djQEH3wM94VfqLTZcOM= +github.com/fatih/color v1.18.0/go.mod h1:4FelSpRwEGDpQ12mAdzqdOukCy4u8WUtOY6lkT/6HfU= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= -github.com/go-faster/errors v0.6.1 h1:nNIPOBkprlKzkThvS/0YaX8Zs9KewLCOSFQS5BU06FI= -github.com/go-faster/errors v0.6.1/go.mod h1:5MGV2/2T9yvlrbhe9pD9LO5Z/2zCSq2T8j+Jpi2LAyY= +github.com/go-faster/errors v0.7.1 h1:MkJTnDoEdi9pDabt1dpWf7AA8/BaSYZqibYyhZ20AYg= +github.com/go-faster/errors v0.7.1/go.mod h1:5ySTjWFiphBs07IKuiL69nxdfd5+fzh1u7FPGZP2quo= github.com/go-faster/jx v1.1.0 h1:ZsW3wD+snOdmTDy9eIVgQdjUpXRRV4rqW8NS3t+20bg= github.com/go-faster/jx v1.1.0/go.mod h1:vKDNikrKoyUmpzaJ0OkIkRQClNHFX/nF3dnTJZb3skg= github.com/go-faster/yaml v0.4.6 h1:lOK/EhI04gCpPgPhgt0bChS6bvw7G3WwI8xxVe0sw9I= github.com/go-faster/yaml v0.4.6/go.mod h1:390dRIvV4zbnO7qC9FGo6YYutc+wyyUSHBgbXL52eXk= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= -github.com/go-logr/logr v1.2.4 h1:g01GSCwiDw2xSZfjJ2/T9M+S6pFdcNtFYsp+Y43HYDQ= -github.com/go-logr/logr v1.2.4/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= +github.com/go-logr/logr v1.4.2 h1:6pFjapn8bFcIbiKo3XT4j/BhANplGihG6tvd+8rYgrY= +github.com/go-logr/logr v1.4.2/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= github.com/go-logr/stdr v1.2.2 h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= github.com/go-logr/stdr v1.2.2/go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= -github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38= -github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= -github.com/google/uuid v1.4.0 h1:MtMxsa51/r9yyhkyLsVeVt0B+BGQZzpQiTQ4eHZ8bc4= -github.com/google/uuid v1.4.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= +github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/websocket v1.5.1 h1:gmztn0JnHVt9JZquRuzLw3g4wouNVzKL15iLr/zn/QY= github.com/gorilla/websocket v1.5.1/go.mod h1:x3kM2JMyaluk02fnUJpQuwD2dCS5NDG2ZHL0uE0tcaY= +github.com/graze/go-throttled v0.3.1 h1:Mr9hMy0GXnbFlOWQl6pjNyn8T+9/LWIv1hJndNhs9mo= +github.com/graze/go-throttled v0.3.1/go.mod h1:OYBew5YhHxQqZGjoa7M8NQLIj+ztV+Iv5xCvzK1sQLg= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= @@ -35,8 +37,8 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae h1:7smdlrfdcZic4VfsGKD2ulWL804a4GVphr4s7WZxGiY= github.com/oasisprotocol/curve25519-voi v0.0.0-20220328075252-7dd334e3daae/go.mod h1:hVoHR2EVESiICEMbg137etN/Lx+lSrHPTD39Z/uE+2s= -github.com/ogen-go/ogen v0.77.0 h1:yREPDg3cDuXkDyp7FPXdPEUz+azPZFUGKmYer8fJpmM= -github.com/ogen-go/ogen v0.77.0/go.mod h1:/bl+MubIppovr7F1fKAaDxzFF+oF2EiMtyVylyqDtQ8= +github.com/ogen-go/ogen v1.8.1 h1:7TZ+oIeLkcBiyl0qu0fHPrFUrGWDj3Fi/zKSWg2i2Tg= +github.com/ogen-go/ogen v1.8.1/go.mod h1:2ShRm6u/nXUHuwdVKv2SeaG8enBKPKAE3kSbHwwFh6o= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/r3labs/sse/v2 v2.10.0 h1:hFEkLLFY4LDifoHdiCN/LlGBAdVJYsANaLqNYa1l/v0= @@ -48,45 +50,48 @@ github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr github.com/snksoft/crc v1.1.0 h1:HkLdI4taFlgGGG1KvsWMpz78PkOC9TkPVpTV/cuWn48= github.com/snksoft/crc v1.1.0/go.mod h1:5/gUOsgAm7OmIhb6WJzw7w5g2zfJi4FrHYgGPdshE+A= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= -github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= -github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/tonkeeper/tongo v1.7.0 h1:ldQkcOZU6FqE1iuwE3UYxXGkmGnu9XlZSaix4qXG3Wk= github.com/tonkeeper/tongo v1.7.0/go.mod h1:MjgIgAytFarjCoVjMLjYEtpZNN1f2G/pnZhKjr28cWs= -go.opentelemetry.io/otel v1.19.0 h1:MuS/TNf4/j4IXsZuJegVzI1cwut7Qc00344rgH7p8bs= -go.opentelemetry.io/otel v1.19.0/go.mod h1:i0QyjOq3UPoTzff0PJB2N66fb4S0+rSbSB15/oyH9fY= -go.opentelemetry.io/otel/metric v1.19.0 h1:aTzpGtV0ar9wlV4Sna9sdJyII5jTVJEvKETPiOKwvpE= -go.opentelemetry.io/otel/metric v1.19.0/go.mod h1:L5rUsV9kM1IxCj1MmSdS+JQAcVm319EUrDVLrt7jqt8= -go.opentelemetry.io/otel/trace v1.19.0 h1:DFVQmlVbfVeOuBRrwdtaehRrWiL1JoVs9CPIQ1Dzxpg= -go.opentelemetry.io/otel/trace v1.19.0/go.mod h1:mfaSyvGyEJEI0nyV2I4qhNQnbBOUUmYZpYojqMnX2vo= -go.uber.org/goleak v1.2.1 h1:NBol2c7O1ZokfZ0LEU9K6Whx/KnwvepVetCUhtKja4A= -go.uber.org/goleak v1.2.1/go.mod h1:qlT2yGI9QafXHhZZLxlSuNsMw3FFLxBr+tBRlmO1xH4= +go.opentelemetry.io/otel v1.32.0 h1:WnBN+Xjcteh0zdk01SVqV55d/m62NJLJdIyb4y/WO5U= +go.opentelemetry.io/otel v1.32.0/go.mod h1:00DCVSB0RQcnzlwyTfqtxSm+DRr9hpYrHjNGiBHVQIg= +go.opentelemetry.io/otel/metric v1.32.0 h1:xV2umtmNcThh2/a/aCP+h64Xx5wsj8qqnkYZktzNa0M= +go.opentelemetry.io/otel/metric v1.32.0/go.mod h1:jH7CIbbK6SH2V2wE16W05BHCtIDzauciCRLoc/SyMv8= +go.opentelemetry.io/otel/trace v1.32.0 h1:WIC9mYrXf8TmY/EXuULKc8hR17vE+Hjv2cssQDe03fM= +go.opentelemetry.io/otel/trace v1.32.0/go.mod h1:+i4rkvCraA+tG6AzwloGaCtkx53Fa+L+V8e9a7YvhT8= +go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= +go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= -go.uber.org/zap v1.26.0 h1:sI7k6L95XOKS281NhVKOFCUNIvv9e0w4BF8N3u+tCRo= -go.uber.org/zap v1.26.0/go.mod h1:dtElttAiwGvoJ/vj4IwHBS/gXsEu/pZ50mUIRWuG0so= +go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= +go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA= -golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs= +golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ= +golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg= golang.org/x/exp v0.0.0-20230725093048-515e97ebf090 h1:Di6/M8l0O2lCLc6VVRWhgCiApHV8MnQurBnFSHsQtNY= golang.org/x/exp v0.0.0-20230725093048-515e97ebf090/go.mod h1:FXUEEKJgO7OQYeo8N01OfiKP8RXMtf6e8aTskBGqWdc= -golang.org/x/mod v0.13.0 h1:I/DsJXRlw/8l/0c24sM9yb0T4z9liZTduXvdAWYiysY= -golang.org/x/mod v0.13.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.22.0 h1:D4nJWe9zXqHOmWqj4VMOJhvzj7bEZg4wEYa759z1pH4= +golang.org/x/mod v0.22.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY= golang.org/x/net v0.0.0-20191116160921-f9c825593386/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.23.0 h1:7EYJ93RZ9vYSZAIb2x3lnuvqO5zneoD6IvWjuhfxjTs= -golang.org/x/net v0.23.0/go.mod h1:JKghWKKOSdJwpW2GEx0Ja7fmaKnMsbu+MWVZTokSYmg= -golang.org/x/sync v0.4.0 h1:zxkM55ReGkDlKSM+Fu41A+zmbZuaPVbGMzvvdUPznYQ= -golang.org/x/sync v0.4.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= +golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo= +golang.org/x/net v0.31.0/go.mod h1:P4fl1q7dY2hnZFxEk4pPSkDHF+QqjitcnDjUQyMM+pM= +golang.org/x/sync v0.9.0 h1:fEo0HyrW1GIgZdpbhCRO0PkJajUS5H9IFUztCgEo2jQ= +golang.org/x/sync v0.9.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= -golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.27.0 h1:wBqf8DvsY9Y/2P8gAfPDEYNuS30J4lPHJxXSb/nJZ+s= +golang.org/x/sys v0.27.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= -golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= -golang.org/x/tools v0.14.0 h1:jvNa2pY0M4r62jkRQ6RwEZZyPcymeL9XZMLBbV7U2nc= -golang.org/x/tools v0.14.0/go.mod h1:uYBEerGOWcJyEORxN+Ek8+TT266gXkNlHdJBwexUsBg= +golang.org/x/text v0.20.0 h1:gK/Kv2otX8gz+wn7Rmb3vT96ZwuoxnQlY+HlJVj7Qug= +golang.org/x/text v0.20.0/go.mod h1:D4IsuqiFMhST5bX19pQ9ikHC2GsaKyk/oF+pn3ducp4= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4 h1:SvFZT6jyqRaOeXpc5h/JSfZenJ2O330aBsf7JfSUXmQ= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.27.0 h1:qEKojBykQkQ4EynWy4S8Weg69NumxKdn40Fce3uc/8o= +golang.org/x/tools v0.27.0/go.mod h1:sUi0ZgbwW9ZPAq26Ekut+weQPR5eIM6GQLQ1Yjm1H0Q= gopkg.in/cenkalti/backoff.v1 v1.1.0 h1:Arh75ttbsvlpVA7WtVpH4u9h6Zl46xuptxqLxPiSo4Y= gopkg.in/cenkalti/backoff.v1 v1.1.0/go.mod h1:J6Vskwqd+OMVJl8C33mmtxTBs2gyzfv7UDAkHu8BrjI= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= diff --git a/oas_cfg_gen.go b/oas_cfg_gen.go index 4ef6ebb..67e18c2 100644 --- a/oas_cfg_gen.go +++ b/oas_cfg_gen.go @@ -40,7 +40,9 @@ func (cfg *otelConfig) initOTEL() { cfg.Tracer = cfg.TracerProvider.Tracer(otelogen.Name, trace.WithInstrumentationVersion(otelogen.SemVersion()), ) - cfg.Meter = cfg.MeterProvider.Meter(otelogen.Name) + cfg.Meter = cfg.MeterProvider.Meter(otelogen.Name, + metric.WithInstrumentationVersion(otelogen.SemVersion()), + ) } type clientConfig struct { @@ -53,15 +55,14 @@ type ClientOption interface { applyClient(*clientConfig) } -var _ = []ClientOption{ - (optionFunc[clientConfig])(nil), - (otelOptionFunc)(nil), -} +var _ ClientOption = (optionFunc[clientConfig])(nil) func (o optionFunc[C]) applyClient(c *C) { o(c) } +var _ ClientOption = (otelOptionFunc)(nil) + func (o otelOptionFunc) applyClient(c *clientConfig) { o(&c.otelConfig) } @@ -86,13 +87,13 @@ type baseClient struct { func (cfg clientConfig) baseClient() (c baseClient, err error) { c = baseClient{cfg: cfg} - if c.requests, err = c.cfg.Meter.Int64Counter(otelogen.ClientRequestCount); err != nil { + if c.requests, err = otelogen.ClientRequestCountCounter(c.cfg.Meter); err != nil { return c, err } - if c.errors, err = c.cfg.Meter.Int64Counter(otelogen.ClientErrorsCount); err != nil { + if c.errors, err = otelogen.ClientErrorsCountCounter(c.cfg.Meter); err != nil { return c, err } - if c.duration, err = c.cfg.Meter.Float64Histogram(otelogen.ClientDuration); err != nil { + if c.duration, err = otelogen.ClientDurationHistogram(c.cfg.Meter); err != nil { return c, err } return c, nil diff --git a/oas_client_gen.go b/oas_client_gen.go index 0f963cb..99f1cfa 100644 --- a/oas_client_gen.go +++ b/oas_client_gen.go @@ -9,14 +9,16 @@ import ( "time" "github.com/go-faster/errors" + "github.com/go-faster/jx" "go.opentelemetry.io/otel/attribute" "go.opentelemetry.io/otel/codes" "go.opentelemetry.io/otel/metric" - semconv "go.opentelemetry.io/otel/semconv/v1.19.0" + semconv "go.opentelemetry.io/otel/semconv/v1.26.0" "go.opentelemetry.io/otel/trace" "github.com/ogen-go/ogen/conv" ht "github.com/ogen-go/ogen/http" + "github.com/ogen-go/ogen/ogenerrors" "github.com/ogen-go/ogen/otelogen" "github.com/ogen-go/ogen/uri" ) @@ -53,27 +55,33 @@ type Invoker interface { // // GET /v2/dns/{domain_name}/resolve DnsResolve(ctx context.Context, params DnsResolveParams) (*DnsRecord, error) + // DownloadBlockchainBlockBoc invokes downloadBlockchainBlockBoc operation. + // + // Download blockchain block BOC. + // + // GET /v2/blockchain/blocks/{block_id}/boc + DownloadBlockchainBlockBoc(ctx context.Context, params DownloadBlockchainBlockBocParams) (*DownloadBlockchainBlockBocOKHeaders, error) // EmulateMessageToAccountEvent invokes emulateMessageToAccountEvent operation. // - // Emulate sending message to blockchain. + // Emulate sending message to retrieve account-specific events. // // POST /v2/accounts/{account_id}/events/emulate EmulateMessageToAccountEvent(ctx context.Context, request *EmulateMessageToAccountEventReq, params EmulateMessageToAccountEventParams) (*AccountEvent, error) // EmulateMessageToEvent invokes emulateMessageToEvent operation. // - // Emulate sending message to blockchain. + // Emulate sending message to retrieve general blockchain events. // // POST /v2/events/emulate EmulateMessageToEvent(ctx context.Context, request *EmulateMessageToEventReq, params EmulateMessageToEventParams) (*Event, error) // EmulateMessageToTrace invokes emulateMessageToTrace operation. // - // Emulate sending message to blockchain. + // Emulate sending message to retrieve with a detailed execution trace. // // POST /v2/traces/emulate EmulateMessageToTrace(ctx context.Context, request *EmulateMessageToTraceReq, params EmulateMessageToTraceParams) (*Trace, error) // EmulateMessageToWallet invokes emulateMessageToWallet operation. // - // Emulate sending message to blockchain. + // Emulate sending message to retrieve the resulting wallet state. // // POST /v2/wallet/emulate EmulateMessageToWallet(ctx context.Context, request *EmulateMessageToWalletReq, params EmulateMessageToWalletParams) (*MessageConsequences, error) @@ -83,6 +91,12 @@ type Invoker interface { // // GET /v2/blockchain/accounts/{account_id}/methods/{method_name} ExecGetMethodForBlockchainAccount(ctx context.Context, params ExecGetMethodForBlockchainAccountParams) (*MethodExecutionResult, error) + // ExecGetMethodWithBodyForBlockchainAccount invokes execGetMethodWithBodyForBlockchainAccount operation. + // + // Execute get method for account. + // + // POST /v2/blockchain/accounts/{account_id}/methods/{method_name} + ExecGetMethodWithBodyForBlockchainAccount(ctx context.Context, request OptExecGetMethodWithBodyForBlockchainAccountReq, params ExecGetMethodWithBodyForBlockchainAccountParams) (*MethodExecutionResult, error) // GaslessConfig invokes gaslessConfig operation. // // Returns configuration of gasless transfers. @@ -97,8 +111,10 @@ type Invoker interface { GaslessEstimate(ctx context.Context, request *GaslessEstimateReq, params GaslessEstimateParams) (*SignRawParams, error) // GaslessSend invokes gaslessSend operation. // + // Submits the signed gasless transaction message to the network. + // // POST /v2/gasless/send - GaslessSend(ctx context.Context, request *GaslessSendReq) error + GaslessSend(ctx context.Context, request *GaslessSendReq) (*GaslessTx, error) // GetAccount invokes getAccount operation. // // Get human-friendly information about an account without low-level details. @@ -133,32 +149,18 @@ type Invoker interface { // // GET /v2/accounts/{account_id}/events GetAccountEvents(ctx context.Context, params GetAccountEventsParams) (*AccountEvents, error) + // GetAccountExtraCurrencyHistoryByID invokes getAccountExtraCurrencyHistoryByID operation. + // + // Get the transfer history of extra currencies for an account. + // + // GET /v2/accounts/{account_id}/extra-currency/{id}/history + GetAccountExtraCurrencyHistoryByID(ctx context.Context, params GetAccountExtraCurrencyHistoryByIDParams) (*AccountEvents, error) // GetAccountInfoByStateInit invokes getAccountInfoByStateInit operation. // // Get account info by state init. // // POST /v2/tonconnect/stateinit GetAccountInfoByStateInit(ctx context.Context, request *GetAccountInfoByStateInitReq) (*AccountInfoByStateInit, error) - // GetAccountInscriptions invokes getAccountInscriptions operation. - // - // Get all inscriptions by owner address. It's experimental API and can be dropped in the future. - // - // GET /v2/experimental/accounts/{account_id}/inscriptions - GetAccountInscriptions(ctx context.Context, params GetAccountInscriptionsParams) (*InscriptionBalances, error) - // GetAccountInscriptionsHistory invokes getAccountInscriptionsHistory operation. - // - // Get the transfer inscriptions history for account. It's experimental API and can be dropped in the - // future. - // - // GET /v2/experimental/accounts/{account_id}/inscriptions/history - GetAccountInscriptionsHistory(ctx context.Context, params GetAccountInscriptionsHistoryParams) (*AccountEvents, error) - // GetAccountInscriptionsHistoryByTicker invokes getAccountInscriptionsHistoryByTicker operation. - // - // Get the transfer inscriptions history for account. It's experimental API and can be dropped in the - // future. - // - // GET /v2/experimental/accounts/{account_id}/inscriptions/{ticker}/history - GetAccountInscriptionsHistoryByTicker(ctx context.Context, params GetAccountInscriptionsHistoryByTickerParams) (*AccountEvents, error) // GetAccountJettonBalance invokes getAccountJettonBalance operation. // // Get Jetton balance by owner address. @@ -167,7 +169,9 @@ type Invoker interface { GetAccountJettonBalance(ctx context.Context, params GetAccountJettonBalanceParams) (*JettonBalance, error) // GetAccountJettonHistoryByID invokes getAccountJettonHistoryByID operation. // - // Get the transfer jetton history for account and jetton. + // Please use `getJettonAccountHistoryByID`` instead. + // + // Deprecated: schema marks this operation as deprecated. // // GET /v2/accounts/{account_id}/jettons/{jetton_id}/history GetAccountJettonHistoryByID(ctx context.Context, params GetAccountJettonHistoryByIDParams) (*AccountEvents, error) @@ -182,7 +186,7 @@ type Invoker interface { // Get the transfer jettons history for account. // // GET /v2/accounts/{account_id}/jettons/history - GetAccountJettonsHistory(ctx context.Context, params GetAccountJettonsHistoryParams) (*AccountEvents, error) + GetAccountJettonsHistory(ctx context.Context, params GetAccountJettonsHistoryParams) (*JettonOperations, error) // GetAccountMultisigs invokes getAccountMultisigs operation. // // Get account's multisigs. @@ -194,7 +198,7 @@ type Invoker interface { // Get the transfer nft history. // // GET /v2/accounts/{account_id}/nfts/history - GetAccountNftHistory(ctx context.Context, params GetAccountNftHistoryParams) (*AccountEvents, error) + GetAccountNftHistory(ctx context.Context, params GetAccountNftHistoryParams) (*NftOperations, error) // GetAccountNftItems invokes getAccountNftItems operation. // // Get all NFT items by owner address. @@ -360,19 +364,24 @@ type Invoker interface { // // GET /v2/events/{event_id} GetEvent(ctx context.Context, params GetEventParams) (*Event, error) - // GetInscriptionOpTemplate invokes getInscriptionOpTemplate operation. + // GetExtraCurrencyInfo invokes getExtraCurrencyInfo operation. // - // Return comment for making operation with inscription. please don't use it if you don't know what - // you are doing. + // Get extra currency info by id. // - // GET /v2/experimental/inscriptions/op-template - GetInscriptionOpTemplate(ctx context.Context, params GetInscriptionOpTemplateParams) (*GetInscriptionOpTemplateOK, error) + // GET /v2/extra-currency/{id} + GetExtraCurrencyInfo(ctx context.Context, params GetExtraCurrencyInfoParams) (*EcPreview, error) // GetItemsFromCollection invokes getItemsFromCollection operation. // // Get NFT items from collection by collection address. // // GET /v2/nfts/collections/{account_id}/items GetItemsFromCollection(ctx context.Context, params GetItemsFromCollectionParams) (*NftItems, error) + // GetJettonAccountHistoryByID invokes getJettonAccountHistoryByID operation. + // + // Get the transfer jetton history for account and jetton. + // + // GET /v2/jettons/{jetton_id}/accounts/{account_id}/history + GetJettonAccountHistoryByID(ctx context.Context, params GetJettonAccountHistoryByIDParams) (*JettonOperations, error) // GetJettonHolders invokes getJettonHolders operation. // // Get jetton's holders. @@ -385,6 +394,12 @@ type Invoker interface { // // GET /v2/jettons/{account_id} GetJettonInfo(ctx context.Context, params GetJettonInfoParams) (*JettonInfo, error) + // GetJettonInfosByAddresses invokes getJettonInfosByAddresses operation. + // + // Get jetton metadata items by jetton master addresses. + // + // POST /v2/jettons/_bulk + GetJettonInfosByAddresses(ctx context.Context, request OptGetJettonInfosByAddressesReq) (*Jettons, error) // GetJettonTransferPayload invokes getJettonTransferPayload operation. // // Get jetton's custom payload and state init required for transfer. @@ -403,6 +418,12 @@ type Invoker interface { // // GET /v2/events/{event_id}/jettons GetJettonsEvents(ctx context.Context, params GetJettonsEventsParams) (*Event, error) + // GetLibraryByHash invokes getLibraryByHash operation. + // + // Get library cell. + // + // GET /v2/blockchain/libraries/{hash} + GetLibraryByHash(ctx context.Context, params GetLibraryByHashParams) (*BlockchainLibrary, error) // GetMarketsRates invokes getMarketsRates operation. // // Get the TON price from markets. @@ -415,12 +436,24 @@ type Invoker interface { // // GET /v2/multisig/{account_id} GetMultisigAccount(ctx context.Context, params GetMultisigAccountParams) (*Multisig, error) + // GetMultisigOrder invokes getMultisigOrder operation. + // + // Get multisig order. + // + // GET /v2/multisig/order/{account_id} + GetMultisigOrder(ctx context.Context, params GetMultisigOrderParams) (*MultisigOrder, error) // GetNftCollection invokes getNftCollection operation. // // Get NFT collection by collection address. // // GET /v2/nfts/collections/{account_id} GetNftCollection(ctx context.Context, params GetNftCollectionParams) (*NftCollection, error) + // GetNftCollectionItemsByAddresses invokes getNftCollectionItemsByAddresses operation. + // + // Get NFT collection items by their addresses. + // + // POST /v2/nfts/collections/_bulk + GetNftCollectionItemsByAddresses(ctx context.Context, request OptGetNftCollectionItemsByAddressesReq) (*NftCollections, error) // GetNftCollections invokes getNftCollections operation. // // Get NFT collections. @@ -429,7 +462,9 @@ type Invoker interface { GetNftCollections(ctx context.Context, params GetNftCollectionsParams) (*NftCollections, error) // GetNftHistoryByID invokes getNftHistoryByID operation. // - // Get the transfer nfts history for account. + // Please use `getAccountNftHistory`` instead. + // + // Deprecated: schema marks this operation as deprecated. // // GET /v2/nfts/{account_id}/history GetNftHistoryByID(ctx context.Context, params GetNftHistoryByIDParams) (*AccountEvents, error) @@ -445,12 +480,30 @@ type Invoker interface { // // POST /v2/nfts/_bulk GetNftItemsByAddresses(ctx context.Context, request OptGetNftItemsByAddressesReq) (*NftItems, error) + // GetOpenapiJson invokes getOpenapiJson operation. + // + // Get the openapi.json file. + // + // GET /v2/openapi.json + GetOpenapiJson(ctx context.Context) (jx.Raw, error) + // GetOpenapiYml invokes getOpenapiYml operation. + // + // Get the openapi.yml file. + // + // GET /v2/openapi.yml + GetOpenapiYml(ctx context.Context) (GetOpenapiYmlOK, error) // GetOutMsgQueueSizes invokes getOutMsgQueueSizes operation. // // Get out msg queue sizes. // // GET /v2/liteserver/get_out_msg_queue_sizes GetOutMsgQueueSizes(ctx context.Context) (*GetOutMsgQueueSizesOK, error) + // GetPurchaseHistory invokes getPurchaseHistory operation. + // + // Get history of purchases. + // + // GET /v2/purchases/{account_id}/history + GetPurchaseHistory(ctx context.Context, params GetPurchaseHistoryParams) (*AccountPurchases, error) // GetRates invokes getRates operation. // // Get the token price in the chosen currency for display only. Don’t use this for financial @@ -590,18 +643,18 @@ type Invoker interface { // // GET /v2/traces/{trace_id} GetTrace(ctx context.Context, params GetTraceParams) (*Trace, error) - // GetWalletBackup invokes getWalletBackup operation. + // GetWalletInfo invokes getWalletInfo operation. // - // Get backup info. + // Get human-friendly information about a wallet without low-level details. // - // GET /v2/wallet/backup - GetWalletBackup(ctx context.Context, params GetWalletBackupParams) (*GetWalletBackupOK, error) + // GET /v2/wallet/{account_id} + GetWalletInfo(ctx context.Context, params GetWalletInfoParams) (*Wallet, error) // GetWalletsByPublicKey invokes getWalletsByPublicKey operation. // // Get wallets by public key. // // GET /v2/pubkeys/{public_key}/wallets - GetWalletsByPublicKey(ctx context.Context, params GetWalletsByPublicKeyParams) (*Accounts, error) + GetWalletsByPublicKey(ctx context.Context, params GetWalletsByPublicKeyParams) (*Wallets, error) // ReindexAccount invokes reindexAccount operation. // // Update internal cache for a particular account. @@ -626,12 +679,6 @@ type Invoker interface { // // POST /v2/liteserver/send_message SendRawMessage(ctx context.Context, request *SendRawMessageReq) (*SendRawMessageOK, error) - // SetWalletBackup invokes setWalletBackup operation. - // - // Set backup info. - // - // PUT /v2/wallet/backup - SetWalletBackup(ctx context.Context, request SetWalletBackupReq, params SetWalletBackupParams) error // Status invokes status operation. // // Status. @@ -649,6 +696,7 @@ type Invoker interface { // Client implements OAS client. type Client struct { serverURL *url.URL + sec SecuritySource baseClient } @@ -658,7 +706,7 @@ func trimTrailingSlashes(u *url.URL) { } // NewClient initializes new Client defined by OAS. -func NewClient(serverURL string, opts ...ClientOption) (*Client, error) { +func NewClient(serverURL string, sec SecuritySource, opts ...ClientOption) (*Client, error) { u, err := url.Parse(serverURL) if err != nil { return nil, err @@ -671,6 +719,7 @@ func NewClient(serverURL string, opts ...ClientOption) (*Client, error) { } return &Client{ serverURL: u, + sec: sec, baseClient: c, }, nil } @@ -703,7 +752,7 @@ func (c *Client) AccountDnsBackResolve(ctx context.Context, params AccountDnsBac func (c *Client) sendAccountDnsBackResolve(ctx context.Context, params AccountDnsBackResolveParams) (res *DomainNames, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("accountDnsBackResolve"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/dns/backresolve"), } @@ -712,14 +761,14 @@ func (c *Client) sendAccountDnsBackResolve(ctx context.Context, params AccountDn 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...)) + c.duration.Record(ctx, 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, "AccountDnsBackResolve", + ctx, span := c.cfg.Tracer.Start(ctx, AccountDnsBackResolveOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -765,6 +814,40 @@ func (c *Client) sendAccountDnsBackResolve(ctx context.Context, params AccountDn return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, AccountDnsBackResolveOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -794,7 +877,7 @@ func (c *Client) AddressParse(ctx context.Context, params AddressParseParams) (* func (c *Client) sendAddressParse(ctx context.Context, params AddressParseParams) (res *AddressParseOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("addressParse"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/address/{account_id}/parse"), } @@ -803,14 +886,14 @@ func (c *Client) sendAddressParse(ctx context.Context, params AddressParseParams 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...)) + c.duration.Record(ctx, 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, "AddressParse", + ctx, span := c.cfg.Tracer.Start(ctx, AddressParseOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -856,6 +939,40 @@ func (c *Client) sendAddressParse(ctx context.Context, params AddressParseParams return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, AddressParseOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -885,7 +1002,7 @@ func (c *Client) BlockchainAccountInspect(ctx context.Context, params Blockchain func (c *Client) sendBlockchainAccountInspect(ctx context.Context, params BlockchainAccountInspectParams) (res *BlockchainAccountInspect, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("blockchainAccountInspect"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/accounts/{account_id}/inspect"), } @@ -894,14 +1011,14 @@ func (c *Client) sendBlockchainAccountInspect(ctx context.Context, params Blockc 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...)) + c.duration.Record(ctx, 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, "BlockchainAccountInspect", + ctx, span := c.cfg.Tracer.Start(ctx, BlockchainAccountInspectOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -947,6 +1064,40 @@ func (c *Client) sendBlockchainAccountInspect(ctx context.Context, params Blockc return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, BlockchainAccountInspectOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -976,7 +1127,7 @@ func (c *Client) DecodeMessage(ctx context.Context, request *DecodeMessageReq) ( func (c *Client) sendDecodeMessage(ctx context.Context, request *DecodeMessageReq) (res *DecodedMessage, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("decodeMessage"), - semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/v2/message/decode"), } @@ -985,14 +1136,14 @@ func (c *Client) sendDecodeMessage(ctx context.Context, request *DecodeMessageRe 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...)) + c.duration.Record(ctx, 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", + ctx, span := c.cfg.Tracer.Start(ctx, DecodeMessageOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -1022,6 +1173,40 @@ func (c *Client) sendDecodeMessage(ctx context.Context, request *DecodeMessageRe return res, errors.Wrap(err, "encode request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, DecodeMessageOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -1051,7 +1236,7 @@ func (c *Client) DnsResolve(ctx context.Context, params DnsResolveParams) (*DnsR func (c *Client) sendDnsResolve(ctx context.Context, params DnsResolveParams) (res *DnsRecord, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("dnsResolve"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/dns/{domain_name}/resolve"), } @@ -1060,14 +1245,14 @@ func (c *Client) sendDnsResolve(ctx context.Context, params DnsResolveParams) (r 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...)) + c.duration.Record(ctx, 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, "DnsResolve", + ctx, span := c.cfg.Tracer.Start(ctx, DnsResolveOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -1107,12 +1292,67 @@ func (c *Client) sendDnsResolve(ctx context.Context, params DnsResolveParams) (r pathParts[2] = "/resolve" uri.AddPathParts(u, pathParts[:]...) + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() + { + // Encode "filter" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "filter", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Filter.Get(); ok { + return e.EncodeValue(conv.BoolToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "GET", u) if err != nil { return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, DnsResolveOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -1129,9 +1369,134 @@ func (c *Client) sendDnsResolve(ctx context.Context, params DnsResolveParams) (r return result, nil } +// DownloadBlockchainBlockBoc invokes downloadBlockchainBlockBoc operation. +// +// Download blockchain block BOC. +// +// GET /v2/blockchain/blocks/{block_id}/boc +func (c *Client) DownloadBlockchainBlockBoc(ctx context.Context, params DownloadBlockchainBlockBocParams) (*DownloadBlockchainBlockBocOKHeaders, error) { + res, err := c.sendDownloadBlockchainBlockBoc(ctx, params) + return res, err +} + +func (c *Client) sendDownloadBlockchainBlockBoc(ctx context.Context, params DownloadBlockchainBlockBocParams) (res *DownloadBlockchainBlockBocOKHeaders, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("downloadBlockchainBlockBoc"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/blockchain/blocks/{block_id}/boc"), + } + + // 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(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, DownloadBlockchainBlockBocOperation, + 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/blocks/" + { + // Encode "block_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "block_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.BlockID)) + }(); 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] = "/boc" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, DownloadBlockchainBlockBocOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + + 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 := decodeDownloadBlockchainBlockBocResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // EmulateMessageToAccountEvent invokes emulateMessageToAccountEvent operation. // -// Emulate sending message to blockchain. +// Emulate sending message to retrieve account-specific events. // // POST /v2/accounts/{account_id}/events/emulate func (c *Client) EmulateMessageToAccountEvent(ctx context.Context, request *EmulateMessageToAccountEventReq, params EmulateMessageToAccountEventParams) (*AccountEvent, error) { @@ -1142,7 +1507,7 @@ func (c *Client) EmulateMessageToAccountEvent(ctx context.Context, request *Emul func (c *Client) sendEmulateMessageToAccountEvent(ctx context.Context, request *EmulateMessageToAccountEventReq, params EmulateMessageToAccountEventParams) (res *AccountEvent, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("emulateMessageToAccountEvent"), - semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/events/emulate"), } @@ -1151,14 +1516,14 @@ func (c *Client) sendEmulateMessageToAccountEvent(ctx context.Context, request * 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...)) + c.duration.Record(ctx, 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, "EmulateMessageToAccountEvent", + ctx, span := c.cfg.Tracer.Start(ctx, EmulateMessageToAccountEventOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -1245,6 +1610,40 @@ func (c *Client) sendEmulateMessageToAccountEvent(ctx context.Context, request * } } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, EmulateMessageToAccountEventOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -1263,7 +1662,7 @@ func (c *Client) sendEmulateMessageToAccountEvent(ctx context.Context, request * // EmulateMessageToEvent invokes emulateMessageToEvent operation. // -// Emulate sending message to blockchain. +// Emulate sending message to retrieve general blockchain events. // // POST /v2/events/emulate func (c *Client) EmulateMessageToEvent(ctx context.Context, request *EmulateMessageToEventReq, params EmulateMessageToEventParams) (*Event, error) { @@ -1274,7 +1673,7 @@ func (c *Client) EmulateMessageToEvent(ctx context.Context, request *EmulateMess func (c *Client) sendEmulateMessageToEvent(ctx context.Context, request *EmulateMessageToEventReq, params EmulateMessageToEventParams) (res *Event, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("emulateMessageToEvent"), - semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/v2/events/emulate"), } @@ -1283,14 +1682,14 @@ func (c *Client) sendEmulateMessageToEvent(ctx context.Context, request *Emulate 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...)) + c.duration.Record(ctx, 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, "EmulateMessageToEvent", + ctx, span := c.cfg.Tracer.Start(ctx, EmulateMessageToEventOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -1358,6 +1757,40 @@ func (c *Client) sendEmulateMessageToEvent(ctx context.Context, request *Emulate } } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, EmulateMessageToEventOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -1376,7 +1809,7 @@ func (c *Client) sendEmulateMessageToEvent(ctx context.Context, request *Emulate // EmulateMessageToTrace invokes emulateMessageToTrace operation. // -// Emulate sending message to blockchain. +// Emulate sending message to retrieve with a detailed execution trace. // // POST /v2/traces/emulate func (c *Client) EmulateMessageToTrace(ctx context.Context, request *EmulateMessageToTraceReq, params EmulateMessageToTraceParams) (*Trace, error) { @@ -1387,7 +1820,7 @@ func (c *Client) EmulateMessageToTrace(ctx context.Context, request *EmulateMess func (c *Client) sendEmulateMessageToTrace(ctx context.Context, request *EmulateMessageToTraceReq, params EmulateMessageToTraceParams) (res *Trace, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("emulateMessageToTrace"), - semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/v2/traces/emulate"), } @@ -1396,14 +1829,14 @@ func (c *Client) sendEmulateMessageToTrace(ctx context.Context, request *Emulate 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...)) + c.duration.Record(ctx, 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, "EmulateMessageToTrace", + ctx, span := c.cfg.Tracer.Start(ctx, EmulateMessageToTraceOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -1454,6 +1887,40 @@ func (c *Client) sendEmulateMessageToTrace(ctx context.Context, request *Emulate return res, errors.Wrap(err, "encode request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, EmulateMessageToTraceOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -1472,7 +1939,7 @@ func (c *Client) sendEmulateMessageToTrace(ctx context.Context, request *Emulate // EmulateMessageToWallet invokes emulateMessageToWallet operation. // -// Emulate sending message to blockchain. +// Emulate sending message to retrieve the resulting wallet state. // // POST /v2/wallet/emulate func (c *Client) EmulateMessageToWallet(ctx context.Context, request *EmulateMessageToWalletReq, params EmulateMessageToWalletParams) (*MessageConsequences, error) { @@ -1483,7 +1950,7 @@ func (c *Client) EmulateMessageToWallet(ctx context.Context, request *EmulateMes func (c *Client) sendEmulateMessageToWallet(ctx context.Context, request *EmulateMessageToWalletReq, params EmulateMessageToWalletParams) (res *MessageConsequences, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("emulateMessageToWallet"), - semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/v2/wallet/emulate"), } @@ -1492,14 +1959,14 @@ func (c *Client) sendEmulateMessageToWallet(ctx context.Context, request *Emulat 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...)) + c.duration.Record(ctx, 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, "EmulateMessageToWallet", + ctx, span := c.cfg.Tracer.Start(ctx, EmulateMessageToWalletOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -1520,6 +1987,27 @@ func (c *Client) sendEmulateMessageToWallet(ctx context.Context, request *Emulat pathParts[0] = "/v2/wallet/emulate" uri.AddPathParts(u, pathParts[:]...) + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() + { + // Encode "currency" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "currency", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Currency.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "POST", u) if err != nil { @@ -1546,6 +2034,40 @@ func (c *Client) sendEmulateMessageToWallet(ctx context.Context, request *Emulat } } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, EmulateMessageToWalletOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -1575,7 +2097,7 @@ func (c *Client) ExecGetMethodForBlockchainAccount(ctx context.Context, params E func (c *Client) sendExecGetMethodForBlockchainAccount(ctx context.Context, params ExecGetMethodForBlockchainAccountParams) (res *MethodExecutionResult, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("execGetMethodForBlockchainAccount"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/accounts/{account_id}/methods/{method_name}"), } @@ -1584,14 +2106,14 @@ func (c *Client) sendExecGetMethodForBlockchainAccount(ctx context.Context, para 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...)) + c.duration.Record(ctx, 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, "ExecGetMethodForBlockchainAccount", + ctx, span := c.cfg.Tracer.Start(ctx, ExecGetMethodForBlockchainAccountOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -1660,16 +2182,19 @@ func (c *Client) sendExecGetMethodForBlockchainAccount(ctx context.Context, para } if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - return e.EncodeArray(func(e uri.Encoder) error { - for i, item := range params.Args { - if err := func() error { - return e.EncodeValue(conv.StringToString(item)) - }(); err != nil { - return errors.Wrapf(err, "[%d]", i) + if params.Args != nil { + return e.EncodeArray(func(e uri.Encoder) error { + for i, item := range params.Args { + if err := func() error { + return e.EncodeValue(conv.StringToString(item)) + }(); err != nil { + return errors.Wrapf(err, "[%d]", i) + } } - } - return nil - }) + return nil + }) + } + return nil }); err != nil { return res, errors.Wrap(err, "encode query") } @@ -1682,6 +2207,40 @@ func (c *Client) sendExecGetMethodForBlockchainAccount(ctx context.Context, para return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, ExecGetMethodForBlockchainAccountOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -1698,6 +2257,168 @@ func (c *Client) sendExecGetMethodForBlockchainAccount(ctx context.Context, para return result, nil } +// ExecGetMethodWithBodyForBlockchainAccount invokes execGetMethodWithBodyForBlockchainAccount operation. +// +// Execute get method for account. +// +// POST /v2/blockchain/accounts/{account_id}/methods/{method_name} +func (c *Client) ExecGetMethodWithBodyForBlockchainAccount(ctx context.Context, request OptExecGetMethodWithBodyForBlockchainAccountReq, params ExecGetMethodWithBodyForBlockchainAccountParams) (*MethodExecutionResult, error) { + res, err := c.sendExecGetMethodWithBodyForBlockchainAccount(ctx, request, params) + return res, err +} + +func (c *Client) sendExecGetMethodWithBodyForBlockchainAccount(ctx context.Context, request OptExecGetMethodWithBodyForBlockchainAccountReq, params ExecGetMethodWithBodyForBlockchainAccountParams) (res *MethodExecutionResult, err error) { + // Validate request before sending. + if err := func() error { + if value, ok := request.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("execGetMethodWithBodyForBlockchainAccount"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/v2/blockchain/accounts/{account_id}/methods/{method_name}"), + } + + // 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(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, ExecGetMethodWithBodyForBlockchainAccountOperation, + 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 [4]string + pathParts[0] = "/v2/blockchain/accounts/" + { + // Encode "account_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "account_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.AccountID)) + }(); 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] = "/methods/" + { + // Encode "method_name" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "method_name", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.MethodName)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + 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 := encodeExecGetMethodWithBodyForBlockchainAccountRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, ExecGetMethodWithBodyForBlockchainAccountOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + + 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 := decodeExecGetMethodWithBodyForBlockchainAccountResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // GaslessConfig invokes gaslessConfig operation. // // Returns configuration of gasless transfers. @@ -1711,7 +2432,7 @@ func (c *Client) GaslessConfig(ctx context.Context) (*GaslessConfig, error) { func (c *Client) sendGaslessConfig(ctx context.Context) (res *GaslessConfig, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("gaslessConfig"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/gasless/config"), } @@ -1720,14 +2441,14 @@ func (c *Client) sendGaslessConfig(ctx context.Context) (res *GaslessConfig, err 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...)) + c.duration.Record(ctx, 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, "GaslessConfig", + ctx, span := c.cfg.Tracer.Start(ctx, GaslessConfigOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -1754,6 +2475,40 @@ func (c *Client) sendGaslessConfig(ctx context.Context) (res *GaslessConfig, err return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GaslessConfigOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -1781,11 +2536,6 @@ func (c *Client) GaslessEstimate(ctx context.Context, request *GaslessEstimateRe } func (c *Client) sendGaslessEstimate(ctx context.Context, request *GaslessEstimateReq, params GaslessEstimateParams) (res *SignRawParams, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("gaslessEstimate"), - semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/v2/gasless/estimate/{master_id}"), - } // Validate request before sending. if err := func() error { if err := request.Validate(); err != nil { @@ -1795,20 +2545,25 @@ func (c *Client) sendGaslessEstimate(ctx context.Context, request *GaslessEstima }(); err != nil { return res, errors.Wrap(err, "validate") } + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("gaslessEstimate"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/v2/gasless/estimate/{master_id}"), + } // 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...)) + c.duration.Record(ctx, 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, "GaslessEstimate", + ctx, span := c.cfg.Tracer.Start(ctx, GaslessEstimateOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -1856,6 +2611,57 @@ func (c *Client) sendGaslessEstimate(ctx context.Context, request *GaslessEstima return res, errors.Wrap(err, "encode request") } + stage = "EncodeHeaderParams" + h := uri.NewHeaderEncoder(r.Header) + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "Accept-Language", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.AcceptLanguage.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode header") + } + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GaslessEstimateOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -1874,16 +2680,18 @@ func (c *Client) sendGaslessEstimate(ctx context.Context, request *GaslessEstima // GaslessSend invokes gaslessSend operation. // +// Submits the signed gasless transaction message to the network. +// // POST /v2/gasless/send -func (c *Client) GaslessSend(ctx context.Context, request *GaslessSendReq) error { - _, err := c.sendGaslessSend(ctx, request) - return err +func (c *Client) GaslessSend(ctx context.Context, request *GaslessSendReq) (*GaslessTx, error) { + res, err := c.sendGaslessSend(ctx, request) + return res, err } -func (c *Client) sendGaslessSend(ctx context.Context, request *GaslessSendReq) (res *GaslessSendOK, err error) { +func (c *Client) sendGaslessSend(ctx context.Context, request *GaslessSendReq) (res *GaslessTx, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("gaslessSend"), - semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/v2/gasless/send"), } @@ -1892,14 +2700,14 @@ func (c *Client) sendGaslessSend(ctx context.Context, request *GaslessSendReq) ( 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...)) + c.duration.Record(ctx, 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, "GaslessSend", + ctx, span := c.cfg.Tracer.Start(ctx, GaslessSendOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -1929,6 +2737,40 @@ func (c *Client) sendGaslessSend(ctx context.Context, request *GaslessSendReq) ( return res, errors.Wrap(err, "encode request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GaslessSendOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -1958,7 +2800,7 @@ func (c *Client) GetAccount(ctx context.Context, params GetAccountParams) (*Acco func (c *Client) sendGetAccount(ctx context.Context, params GetAccountParams) (res *Account, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccount"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}"), } @@ -1967,14 +2809,14 @@ func (c *Client) sendGetAccount(ctx context.Context, params GetAccountParams) (r 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...)) + c.duration.Record(ctx, 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, "GetAccount", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -2019,6 +2861,40 @@ func (c *Client) sendGetAccount(ctx context.Context, params GetAccountParams) (r return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -2048,7 +2924,7 @@ func (c *Client) GetAccountDiff(ctx context.Context, params GetAccountDiffParams func (c *Client) sendGetAccountDiff(ctx context.Context, params GetAccountDiffParams) (res *GetAccountDiffOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountDiff"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/diff"), } @@ -2057,14 +2933,14 @@ func (c *Client) sendGetAccountDiff(ctx context.Context, params GetAccountDiffPa 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...)) + c.duration.Record(ctx, 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, "GetAccountDiff", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountDiffOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -2142,6 +3018,40 @@ func (c *Client) sendGetAccountDiff(ctx context.Context, params GetAccountDiffPa return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountDiffOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -2171,7 +3081,7 @@ func (c *Client) GetAccountDnsExpiring(ctx context.Context, params GetAccountDns func (c *Client) sendGetAccountDnsExpiring(ctx context.Context, params GetAccountDnsExpiringParams) (res *DnsExpiring, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountDnsExpiring"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/dns/expiring"), } @@ -2180,14 +3090,14 @@ func (c *Client) sendGetAccountDnsExpiring(ctx context.Context, params GetAccoun 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...)) + c.duration.Record(ctx, 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, "GetAccountDnsExpiring", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountDnsExpiringOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -2254,6 +3164,40 @@ func (c *Client) sendGetAccountDnsExpiring(ctx context.Context, params GetAccoun return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountDnsExpiringOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -2283,7 +3227,7 @@ func (c *Client) GetAccountEvent(ctx context.Context, params GetAccountEventPara func (c *Client) sendGetAccountEvent(ctx context.Context, params GetAccountEventParams) (res *AccountEvent, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountEvent"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/events/{event_id}"), } @@ -2292,14 +3236,14 @@ func (c *Client) sendGetAccountEvent(ctx context.Context, params GetAccountEvent 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...)) + c.duration.Record(ctx, 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, "GetAccountEvent", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountEventOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -2401,6 +3345,40 @@ func (c *Client) sendGetAccountEvent(ctx context.Context, params GetAccountEvent } } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountEventOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -2434,7 +3412,7 @@ func (c *Client) GetAccountEvents(ctx context.Context, params GetAccountEventsPa func (c *Client) sendGetAccountEvents(ctx context.Context, params GetAccountEventsParams) (res *AccountEvents, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountEvents"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/events"), } @@ -2443,14 +3421,14 @@ func (c *Client) sendGetAccountEvents(ctx context.Context, params GetAccountEven 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...)) + c.duration.Record(ctx, 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, "GetAccountEvents", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountEventsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -2616,6 +3594,40 @@ func (c *Client) sendGetAccountEvents(ctx context.Context, params GetAccountEven } } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountEventsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -2632,96 +3644,21 @@ func (c *Client) sendGetAccountEvents(ctx context.Context, params GetAccountEven return result, nil } -// GetAccountInfoByStateInit invokes getAccountInfoByStateInit operation. +// GetAccountExtraCurrencyHistoryByID invokes getAccountExtraCurrencyHistoryByID operation. // -// Get account info by state init. +// Get the transfer history of extra currencies for an account. // -// POST /v2/tonconnect/stateinit -func (c *Client) GetAccountInfoByStateInit(ctx context.Context, request *GetAccountInfoByStateInitReq) (*AccountInfoByStateInit, error) { - res, err := c.sendGetAccountInfoByStateInit(ctx, request) - return res, err -} - -func (c *Client) sendGetAccountInfoByStateInit(ctx context.Context, request *GetAccountInfoByStateInitReq) (res *AccountInfoByStateInit, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getAccountInfoByStateInit"), - semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/v2/tonconnect/stateinit"), - } - - // 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, "GetAccountInfoByStateInit", - 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/tonconnect/stateinit" - 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 := encodeGetAccountInfoByStateInitRequest(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 := decodeGetAccountInfoByStateInitResponse(resp) - if err != nil { - return res, errors.Wrap(err, "decode response") - } - - return result, nil -} - -// GetAccountInscriptions invokes getAccountInscriptions operation. -// -// Get all inscriptions by owner address. It's experimental API and can be dropped in the future. -// -// GET /v2/experimental/accounts/{account_id}/inscriptions -func (c *Client) GetAccountInscriptions(ctx context.Context, params GetAccountInscriptionsParams) (*InscriptionBalances, error) { - res, err := c.sendGetAccountInscriptions(ctx, params) +// GET /v2/accounts/{account_id}/extra-currency/{id}/history +func (c *Client) GetAccountExtraCurrencyHistoryByID(ctx context.Context, params GetAccountExtraCurrencyHistoryByIDParams) (*AccountEvents, error) { + res, err := c.sendGetAccountExtraCurrencyHistoryByID(ctx, params) return res, err } -func (c *Client) sendGetAccountInscriptions(ctx context.Context, params GetAccountInscriptionsParams) (res *InscriptionBalances, err error) { +func (c *Client) sendGetAccountExtraCurrencyHistoryByID(ctx context.Context, params GetAccountExtraCurrencyHistoryByIDParams) (res *AccountEvents, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getAccountInscriptions"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/experimental/accounts/{account_id}/inscriptions"), + otelogen.OperationID("getAccountExtraCurrencyHistoryByID"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/extra-currency/{id}/history"), } // Run stopwatch. @@ -2729,14 +3666,14 @@ func (c *Client) sendGetAccountInscriptions(ctx context.Context, params GetAccou 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...)) + c.duration.Record(ctx, 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, "GetAccountInscriptions", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountExtraCurrencyHistoryByIDOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -2753,8 +3690,8 @@ func (c *Client) sendGetAccountInscriptions(ctx context.Context, params GetAccou stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) - var pathParts [3]string - pathParts[0] = "/v2/experimental/accounts/" + var pathParts [5]string + pathParts[0] = "/v2/accounts/" { // Encode "account_id" parameter. e := uri.NewPathEncoder(uri.PathEncoderConfig{ @@ -2773,11 +3710,47 @@ func (c *Client) sendGetAccountInscriptions(ctx context.Context, params GetAccou } pathParts[1] = encoded } - pathParts[2] = "/inscriptions" + pathParts[2] = "/extra-currency/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.Int32ToString(params.ID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + pathParts[4] = "/history" uri.AddPathParts(u, pathParts[:]...) stage = "EncodeQueryParams" q := uri.NewQueryEncoder() + { + // Encode "before_lt" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "before_lt", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.BeforeLt.Get(); ok { + return e.EncodeValue(conv.Int64ToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } { // Encode "limit" parameter. cfg := uri.QueryParameterEncodingConfig{ @@ -2787,8 +3760,22 @@ func (c *Client) sendGetAccountInscriptions(ctx context.Context, params GetAccou } if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.Limit.Get(); ok { - return e.EncodeValue(conv.IntToString(val)) + return e.EncodeValue(conv.IntToString(params.Limit)) + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "start_date" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "start_date", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.StartDate.Get(); ok { + return e.EncodeValue(conv.Int64ToString(val)) } return nil }); err != nil { @@ -2796,16 +3783,16 @@ func (c *Client) sendGetAccountInscriptions(ctx context.Context, params GetAccou } } { - // Encode "offset" parameter. + // Encode "end_date" parameter. cfg := uri.QueryParameterEncodingConfig{ - Name: "offset", + Name: "end_date", Style: uri.QueryStyleForm, Explode: true, } if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.Offset.Get(); ok { - return e.EncodeValue(conv.IntToString(val)) + if val, ok := params.EndDate.Get(); ok { + return e.EncodeValue(conv.Int64ToString(val)) } return nil }); err != nil { @@ -2820,6 +3807,57 @@ func (c *Client) sendGetAccountInscriptions(ctx context.Context, params GetAccou return res, errors.Wrap(err, "create request") } + stage = "EncodeHeaderParams" + h := uri.NewHeaderEncoder(r.Header) + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "Accept-Language", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.AcceptLanguage.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode header") + } + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountExtraCurrencyHistoryByIDOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -2828,7 +3866,7 @@ func (c *Client) sendGetAccountInscriptions(ctx context.Context, params GetAccou defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetAccountInscriptionsResponse(resp) + result, err := decodeGetAccountExtraCurrencyHistoryByIDResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -2836,22 +3874,21 @@ func (c *Client) sendGetAccountInscriptions(ctx context.Context, params GetAccou return result, nil } -// GetAccountInscriptionsHistory invokes getAccountInscriptionsHistory operation. +// GetAccountInfoByStateInit invokes getAccountInfoByStateInit operation. // -// Get the transfer inscriptions history for account. It's experimental API and can be dropped in the -// future. +// Get account info by state init. // -// GET /v2/experimental/accounts/{account_id}/inscriptions/history -func (c *Client) GetAccountInscriptionsHistory(ctx context.Context, params GetAccountInscriptionsHistoryParams) (*AccountEvents, error) { - res, err := c.sendGetAccountInscriptionsHistory(ctx, params) +// POST /v2/tonconnect/stateinit +func (c *Client) GetAccountInfoByStateInit(ctx context.Context, request *GetAccountInfoByStateInitReq) (*AccountInfoByStateInit, error) { + res, err := c.sendGetAccountInfoByStateInit(ctx, request) return res, err } -func (c *Client) sendGetAccountInscriptionsHistory(ctx context.Context, params GetAccountInscriptionsHistoryParams) (res *AccountEvents, err error) { +func (c *Client) sendGetAccountInfoByStateInit(ctx context.Context, request *GetAccountInfoByStateInitReq) (res *AccountInfoByStateInit, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getAccountInscriptionsHistory"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/experimental/accounts/{account_id}/inscriptions/history"), + otelogen.OperationID("getAccountInfoByStateInit"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/v2/tonconnect/stateinit"), } // Run stopwatch. @@ -2859,14 +3896,14 @@ func (c *Client) sendGetAccountInscriptionsHistory(ctx context.Context, params G 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...)) + c.duration.Record(ctx, 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, "GetAccountInscriptionsHistory", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountInfoByStateInitOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -2883,87 +3920,50 @@ func (c *Client) sendGetAccountInscriptionsHistory(ctx context.Context, params G stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) - var pathParts [3]string - pathParts[0] = "/v2/experimental/accounts/" - { - // Encode "account_id" parameter. - e := uri.NewPathEncoder(uri.PathEncoderConfig{ - Param: "account_id", - Style: uri.PathStyleSimple, - Explode: false, - }) - if err := func() error { - return e.EncodeValue(conv.StringToString(params.AccountID)) - }(); 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] = "/inscriptions/history" + var pathParts [1]string + pathParts[0] = "/v2/tonconnect/stateinit" uri.AddPathParts(u, pathParts[:]...) - stage = "EncodeQueryParams" - q := uri.NewQueryEncoder() - { - // Encode "before_lt" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "before_lt", - Style: uri.QueryStyleForm, - Explode: true, - } - - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.BeforeLt.Get(); ok { - return e.EncodeValue(conv.Int64ToString(val)) - } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode query") - } - } - { - // Encode "limit" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "limit", - Style: uri.QueryStyleForm, - Explode: true, - } - - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.Limit.Get(); ok { - return e.EncodeValue(conv.IntToString(val)) - } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode query") - } - } - u.RawQuery = q.Values().Encode() - stage = "EncodeRequest" - r, err := ht.NewRequest(ctx, "GET", u) + r, err := ht.NewRequest(ctx, "POST", u) if err != nil { return res, errors.Wrap(err, "create request") } + if err := encodeGetAccountInfoByStateInitRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } - stage = "EncodeHeaderParams" - h := uri.NewHeaderEncoder(r.Header) { - cfg := uri.HeaderParameterEncodingConfig{ - Name: "Accept-Language", - Explode: false, + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountInfoByStateInitOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } } - if err := h.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.AcceptLanguage.Get(); ok { - return e.EncodeValue(conv.StringToString(val)) + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode header") + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied } } @@ -2975,7 +3975,7 @@ func (c *Client) sendGetAccountInscriptionsHistory(ctx context.Context, params G defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetAccountInscriptionsHistoryResponse(resp) + result, err := decodeGetAccountInfoByStateInitResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -2983,22 +3983,21 @@ func (c *Client) sendGetAccountInscriptionsHistory(ctx context.Context, params G return result, nil } -// GetAccountInscriptionsHistoryByTicker invokes getAccountInscriptionsHistoryByTicker operation. +// GetAccountJettonBalance invokes getAccountJettonBalance operation. // -// Get the transfer inscriptions history for account. It's experimental API and can be dropped in the -// future. +// Get Jetton balance by owner address. // -// GET /v2/experimental/accounts/{account_id}/inscriptions/{ticker}/history -func (c *Client) GetAccountInscriptionsHistoryByTicker(ctx context.Context, params GetAccountInscriptionsHistoryByTickerParams) (*AccountEvents, error) { - res, err := c.sendGetAccountInscriptionsHistoryByTicker(ctx, params) +// GET /v2/accounts/{account_id}/jettons/{jetton_id} +func (c *Client) GetAccountJettonBalance(ctx context.Context, params GetAccountJettonBalanceParams) (*JettonBalance, error) { + res, err := c.sendGetAccountJettonBalance(ctx, params) return res, err } -func (c *Client) sendGetAccountInscriptionsHistoryByTicker(ctx context.Context, params GetAccountInscriptionsHistoryByTickerParams) (res *AccountEvents, err error) { +func (c *Client) sendGetAccountJettonBalance(ctx context.Context, params GetAccountJettonBalanceParams) (res *JettonBalance, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getAccountInscriptionsHistoryByTicker"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/experimental/accounts/{account_id}/inscriptions/{ticker}/history"), + otelogen.OperationID("getAccountJettonBalance"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/jettons/{jetton_id}"), } // Run stopwatch. @@ -3006,14 +4005,14 @@ func (c *Client) sendGetAccountInscriptionsHistoryByTicker(ctx context.Context, 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...)) + c.duration.Record(ctx, 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, "GetAccountInscriptionsHistoryByTicker", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountJettonBalanceOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -3030,8 +4029,8 @@ func (c *Client) sendGetAccountInscriptionsHistoryByTicker(ctx context.Context, stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) - var pathParts [5]string - pathParts[0] = "/v2/experimental/accounts/" + var pathParts [4]string + pathParts[0] = "/v2/accounts/" { // Encode "account_id" parameter. e := uri.NewPathEncoder(uri.PathEncoderConfig{ @@ -3050,16 +4049,16 @@ func (c *Client) sendGetAccountInscriptionsHistoryByTicker(ctx context.Context, } pathParts[1] = encoded } - pathParts[2] = "/inscriptions/" + pathParts[2] = "/jettons/" { - // Encode "ticker" parameter. + // Encode "jetton_id" parameter. e := uri.NewPathEncoder(uri.PathEncoderConfig{ - Param: "ticker", + Param: "jetton_id", Style: uri.PathStyleSimple, Explode: false, }) if err := func() error { - return e.EncodeValue(conv.StringToString(params.Ticker)) + return e.EncodeValue(conv.StringToString(params.JettonID)) }(); err != nil { return res, errors.Wrap(err, "encode path") } @@ -3069,22 +4068,30 @@ func (c *Client) sendGetAccountInscriptionsHistoryByTicker(ctx context.Context, } pathParts[3] = encoded } - pathParts[4] = "/history" uri.AddPathParts(u, pathParts[:]...) stage = "EncodeQueryParams" q := uri.NewQueryEncoder() { - // Encode "before_lt" parameter. + // Encode "currencies" parameter. cfg := uri.QueryParameterEncodingConfig{ - Name: "before_lt", + Name: "currencies", Style: uri.QueryStyleForm, - Explode: true, + Explode: false, } if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.BeforeLt.Get(); ok { - return e.EncodeValue(conv.Int64ToString(val)) + if params.Currencies != nil { + return e.EncodeArray(func(e uri.Encoder) error { + for i, item := range params.Currencies { + if err := func() error { + return e.EncodeValue(conv.StringToString(item)) + }(); err != nil { + return errors.Wrapf(err, "[%d]", i) + } + } + return nil + }) } return nil }); err != nil { @@ -3092,16 +4099,25 @@ func (c *Client) sendGetAccountInscriptionsHistoryByTicker(ctx context.Context, } } { - // Encode "limit" parameter. + // Encode "supported_extensions" parameter. cfg := uri.QueryParameterEncodingConfig{ - Name: "limit", + Name: "supported_extensions", Style: uri.QueryStyleForm, - Explode: true, + Explode: false, } if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.Limit.Get(); ok { - return e.EncodeValue(conv.IntToString(val)) + if params.SupportedExtensions != nil { + return e.EncodeArray(func(e uri.Encoder) error { + for i, item := range params.SupportedExtensions { + if err := func() error { + return e.EncodeValue(conv.StringToString(item)) + }(); err != nil { + return errors.Wrapf(err, "[%d]", i) + } + } + return nil + }) } return nil }); err != nil { @@ -3116,158 +4132,39 @@ func (c *Client) sendGetAccountInscriptionsHistoryByTicker(ctx context.Context, return res, errors.Wrap(err, "create request") } - stage = "EncodeHeaderParams" - h := uri.NewHeaderEncoder(r.Header) { - cfg := uri.HeaderParameterEncodingConfig{ - Name: "Accept-Language", - Explode: false, - } - if err := h.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.AcceptLanguage.Get(); ok { - return e.EncodeValue(conv.StringToString(val)) + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountJettonBalanceOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode header") - } - } - - 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 := decodeGetAccountInscriptionsHistoryByTickerResponse(resp) - if err != nil { - return res, errors.Wrap(err, "decode response") - } - - return result, nil -} - -// GetAccountJettonBalance invokes getAccountJettonBalance operation. -// -// Get Jetton balance by owner address. -// -// GET /v2/accounts/{account_id}/jettons/{jetton_id} -func (c *Client) GetAccountJettonBalance(ctx context.Context, params GetAccountJettonBalanceParams) (*JettonBalance, error) { - res, err := c.sendGetAccountJettonBalance(ctx, params) - return res, err -} - -func (c *Client) sendGetAccountJettonBalance(ctx context.Context, params GetAccountJettonBalanceParams) (res *JettonBalance, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getAccountJettonBalance"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/jettons/{jetton_id}"), - } - - // 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, "GetAccountJettonBalance", - 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 [4]string - pathParts[0] = "/v2/accounts/" - { - // Encode "account_id" parameter. - e := uri.NewPathEncoder(uri.PathEncoderConfig{ - Param: "account_id", - Style: uri.PathStyleSimple, - Explode: false, - }) - if err := func() error { - return e.EncodeValue(conv.StringToString(params.AccountID)) - }(); 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] = "/jettons/" - { - // Encode "jetton_id" parameter. - e := uri.NewPathEncoder(uri.PathEncoderConfig{ - Param: "jetton_id", - Style: uri.PathStyleSimple, - Explode: false, - }) - if err := func() error { - return e.EncodeValue(conv.StringToString(params.JettonID)) - }(); err != nil { - return res, errors.Wrap(err, "encode path") - } - encoded, err := e.Result() - if err != nil { - return res, errors.Wrap(err, "encode path") - } - pathParts[3] = encoded - } - uri.AddPathParts(u, pathParts[:]...) - - stage = "EncodeQueryParams" - q := uri.NewQueryEncoder() - { - // Encode "currencies" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "currencies", - Style: uri.QueryStyleForm, - Explode: false, } - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - return e.EncodeArray(func(e uri.Encoder) error { - for i, item := range params.Currencies { - if err := func() error { - return e.EncodeValue(conv.StringToString(item)) - }(); err != nil { - return errors.Wrapf(err, "[%d]", i) + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement } } - return nil - }) - }); err != nil { - return res, errors.Wrap(err, "encode query") + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied } } - u.RawQuery = q.Values().Encode() - - 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) @@ -3287,7 +4184,9 @@ func (c *Client) sendGetAccountJettonBalance(ctx context.Context, params GetAcco // GetAccountJettonHistoryByID invokes getAccountJettonHistoryByID operation. // -// Get the transfer jetton history for account and jetton. +// Please use `getJettonAccountHistoryByID“ instead. +// +// Deprecated: schema marks this operation as deprecated. // // GET /v2/accounts/{account_id}/jettons/{jetton_id}/history func (c *Client) GetAccountJettonHistoryByID(ctx context.Context, params GetAccountJettonHistoryByIDParams) (*AccountEvents, error) { @@ -3298,7 +4197,7 @@ func (c *Client) GetAccountJettonHistoryByID(ctx context.Context, params GetAcco func (c *Client) sendGetAccountJettonHistoryByID(ctx context.Context, params GetAccountJettonHistoryByIDParams) (res *AccountEvents, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountJettonHistoryByID"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/jettons/{jetton_id}/history"), } @@ -3307,14 +4206,14 @@ func (c *Client) sendGetAccountJettonHistoryByID(ctx context.Context, params Get 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...)) + c.duration.Record(ctx, 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, "GetAccountJettonHistoryByID", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountJettonHistoryByIDOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -3465,6 +4364,40 @@ func (c *Client) sendGetAccountJettonHistoryByID(ctx context.Context, params Get } } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountJettonHistoryByIDOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -3494,7 +4427,7 @@ func (c *Client) GetAccountJettonsBalances(ctx context.Context, params GetAccoun func (c *Client) sendGetAccountJettonsBalances(ctx context.Context, params GetAccountJettonsBalancesParams) (res *JettonsBalances, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountJettonsBalances"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/jettons"), } @@ -3503,14 +4436,14 @@ func (c *Client) sendGetAccountJettonsBalances(ctx context.Context, params GetAc 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...)) + c.duration.Record(ctx, 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, "GetAccountJettonsBalances", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountJettonsBalancesOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -3561,16 +4494,19 @@ func (c *Client) sendGetAccountJettonsBalances(ctx context.Context, params GetAc } if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - return e.EncodeArray(func(e uri.Encoder) error { - for i, item := range params.Currencies { - if err := func() error { - return e.EncodeValue(conv.StringToString(item)) - }(); err != nil { - return errors.Wrapf(err, "[%d]", i) + if params.Currencies != nil { + return e.EncodeArray(func(e uri.Encoder) error { + for i, item := range params.Currencies { + if err := func() error { + return e.EncodeValue(conv.StringToString(item)) + }(); err != nil { + return errors.Wrapf(err, "[%d]", i) + } } - } - return nil - }) + return nil + }) + } + return nil }); err != nil { return res, errors.Wrap(err, "encode query") } @@ -3584,16 +4520,19 @@ func (c *Client) sendGetAccountJettonsBalances(ctx context.Context, params GetAc } if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - return e.EncodeArray(func(e uri.Encoder) error { - for i, item := range params.SupportedExtensions { - if err := func() error { - return e.EncodeValue(conv.StringToString(item)) - }(); err != nil { - return errors.Wrapf(err, "[%d]", i) + if params.SupportedExtensions != nil { + return e.EncodeArray(func(e uri.Encoder) error { + for i, item := range params.SupportedExtensions { + if err := func() error { + return e.EncodeValue(conv.StringToString(item)) + }(); err != nil { + return errors.Wrapf(err, "[%d]", i) + } } - } - return nil - }) + return nil + }) + } + return nil }); err != nil { return res, errors.Wrap(err, "encode query") } @@ -3606,6 +4545,40 @@ func (c *Client) sendGetAccountJettonsBalances(ctx context.Context, params GetAc return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountJettonsBalancesOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -3627,15 +4600,15 @@ func (c *Client) sendGetAccountJettonsBalances(ctx context.Context, params GetAc // Get the transfer jettons history for account. // // GET /v2/accounts/{account_id}/jettons/history -func (c *Client) GetAccountJettonsHistory(ctx context.Context, params GetAccountJettonsHistoryParams) (*AccountEvents, error) { +func (c *Client) GetAccountJettonsHistory(ctx context.Context, params GetAccountJettonsHistoryParams) (*JettonOperations, error) { res, err := c.sendGetAccountJettonsHistory(ctx, params) return res, err } -func (c *Client) sendGetAccountJettonsHistory(ctx context.Context, params GetAccountJettonsHistoryParams) (res *AccountEvents, err error) { +func (c *Client) sendGetAccountJettonsHistory(ctx context.Context, params GetAccountJettonsHistoryParams) (res *JettonOperations, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountJettonsHistory"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/jettons/history"), } @@ -3644,14 +4617,14 @@ func (c *Client) sendGetAccountJettonsHistory(ctx context.Context, params GetAcc 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...)) + c.duration.Record(ctx, 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, "GetAccountJettonsHistory", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountJettonsHistoryOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -3724,40 +4697,6 @@ func (c *Client) sendGetAccountJettonsHistory(ctx context.Context, params GetAcc return res, errors.Wrap(err, "encode query") } } - { - // Encode "start_date" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "start_date", - Style: uri.QueryStyleForm, - Explode: true, - } - - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.StartDate.Get(); ok { - return e.EncodeValue(conv.Int64ToString(val)) - } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode query") - } - } - { - // Encode "end_date" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "end_date", - Style: uri.QueryStyleForm, - Explode: true, - } - - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.EndDate.Get(); ok { - return e.EncodeValue(conv.Int64ToString(val)) - } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode query") - } - } u.RawQuery = q.Values().Encode() stage = "EncodeRequest" @@ -3766,20 +4705,37 @@ func (c *Client) sendGetAccountJettonsHistory(ctx context.Context, params GetAcc return res, errors.Wrap(err, "create request") } - stage = "EncodeHeaderParams" - h := uri.NewHeaderEncoder(r.Header) { - cfg := uri.HeaderParameterEncodingConfig{ - Name: "Accept-Language", - Explode: false, + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountJettonsHistoryOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } } - if err := h.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.AcceptLanguage.Get(); ok { - return e.EncodeValue(conv.StringToString(val)) + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode header") + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied } } @@ -3812,7 +4768,7 @@ func (c *Client) GetAccountMultisigs(ctx context.Context, params GetAccountMulti func (c *Client) sendGetAccountMultisigs(ctx context.Context, params GetAccountMultisigsParams) (res *Multisigs, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountMultisigs"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/multisigs"), } @@ -3821,14 +4777,14 @@ func (c *Client) sendGetAccountMultisigs(ctx context.Context, params GetAccountM 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...)) + c.duration.Record(ctx, 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, "GetAccountMultisigs", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountMultisigsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -3874,6 +4830,40 @@ func (c *Client) sendGetAccountMultisigs(ctx context.Context, params GetAccountM return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountMultisigsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -3895,15 +4885,15 @@ func (c *Client) sendGetAccountMultisigs(ctx context.Context, params GetAccountM // Get the transfer nft history. // // GET /v2/accounts/{account_id}/nfts/history -func (c *Client) GetAccountNftHistory(ctx context.Context, params GetAccountNftHistoryParams) (*AccountEvents, error) { +func (c *Client) GetAccountNftHistory(ctx context.Context, params GetAccountNftHistoryParams) (*NftOperations, error) { res, err := c.sendGetAccountNftHistory(ctx, params) return res, err } -func (c *Client) sendGetAccountNftHistory(ctx context.Context, params GetAccountNftHistoryParams) (res *AccountEvents, err error) { +func (c *Client) sendGetAccountNftHistory(ctx context.Context, params GetAccountNftHistoryParams) (res *NftOperations, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountNftHistory"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/nfts/history"), } @@ -3912,14 +4902,14 @@ func (c *Client) sendGetAccountNftHistory(ctx context.Context, params GetAccount 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...)) + c.duration.Record(ctx, 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, "GetAccountNftHistory", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountNftHistoryOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -3992,40 +4982,6 @@ func (c *Client) sendGetAccountNftHistory(ctx context.Context, params GetAccount return res, errors.Wrap(err, "encode query") } } - { - // Encode "start_date" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "start_date", - Style: uri.QueryStyleForm, - Explode: true, - } - - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.StartDate.Get(); ok { - return e.EncodeValue(conv.Int64ToString(val)) - } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode query") - } - } - { - // Encode "end_date" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "end_date", - Style: uri.QueryStyleForm, - Explode: true, - } - - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.EndDate.Get(); ok { - return e.EncodeValue(conv.Int64ToString(val)) - } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode query") - } - } u.RawQuery = q.Values().Encode() stage = "EncodeRequest" @@ -4051,6 +5007,40 @@ func (c *Client) sendGetAccountNftHistory(ctx context.Context, params GetAccount } } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountNftHistoryOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -4080,7 +5070,7 @@ func (c *Client) GetAccountNftItems(ctx context.Context, params GetAccountNftIte func (c *Client) sendGetAccountNftItems(ctx context.Context, params GetAccountNftItemsParams) (res *NftItems, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountNftItems"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/nfts"), } @@ -4089,14 +5079,14 @@ func (c *Client) sendGetAccountNftItems(ctx context.Context, params GetAccountNf 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...)) + c.duration.Record(ctx, 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, "GetAccountNftItems", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountNftItemsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -4214,6 +5204,40 @@ func (c *Client) sendGetAccountNftItems(ctx context.Context, params GetAccountNf return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountNftItemsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -4243,7 +5267,7 @@ func (c *Client) GetAccountNominatorsPools(ctx context.Context, params GetAccoun func (c *Client) sendGetAccountNominatorsPools(ctx context.Context, params GetAccountNominatorsPoolsParams) (res *AccountStaking, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountNominatorsPools"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/staking/nominator/{account_id}/pools"), } @@ -4252,14 +5276,14 @@ func (c *Client) sendGetAccountNominatorsPools(ctx context.Context, params GetAc 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...)) + c.duration.Record(ctx, 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, "GetAccountNominatorsPools", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountNominatorsPoolsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -4305,6 +5329,40 @@ func (c *Client) sendGetAccountNominatorsPools(ctx context.Context, params GetAc return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountNominatorsPoolsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -4334,7 +5392,7 @@ func (c *Client) GetAccountPublicKey(ctx context.Context, params GetAccountPubli func (c *Client) sendGetAccountPublicKey(ctx context.Context, params GetAccountPublicKeyParams) (res *GetAccountPublicKeyOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountPublicKey"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/publickey"), } @@ -4343,14 +5401,14 @@ func (c *Client) sendGetAccountPublicKey(ctx context.Context, params GetAccountP 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...)) + c.duration.Record(ctx, 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, "GetAccountPublicKey", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountPublicKeyOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -4396,6 +5454,40 @@ func (c *Client) sendGetAccountPublicKey(ctx context.Context, params GetAccountP return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountPublicKeyOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -4425,7 +5517,7 @@ func (c *Client) GetAccountSeqno(ctx context.Context, params GetAccountSeqnoPara func (c *Client) sendGetAccountSeqno(ctx context.Context, params GetAccountSeqnoParams) (res *Seqno, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountSeqno"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/wallet/{account_id}/seqno"), } @@ -4434,14 +5526,14 @@ func (c *Client) sendGetAccountSeqno(ctx context.Context, params GetAccountSeqno 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...)) + c.duration.Record(ctx, 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, "GetAccountSeqno", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountSeqnoOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -4487,6 +5579,40 @@ func (c *Client) sendGetAccountSeqno(ctx context.Context, params GetAccountSeqno return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountSeqnoOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -4516,7 +5642,7 @@ func (c *Client) GetAccountSubscriptions(ctx context.Context, params GetAccountS func (c *Client) sendGetAccountSubscriptions(ctx context.Context, params GetAccountSubscriptionsParams) (res *Subscriptions, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountSubscriptions"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/subscriptions"), } @@ -4525,14 +5651,14 @@ func (c *Client) sendGetAccountSubscriptions(ctx context.Context, params GetAcco 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...)) + c.duration.Record(ctx, 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, "GetAccountSubscriptions", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountSubscriptionsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -4578,6 +5704,40 @@ func (c *Client) sendGetAccountSubscriptions(ctx context.Context, params GetAcco return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountSubscriptionsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -4607,7 +5767,7 @@ func (c *Client) GetAccountTraces(ctx context.Context, params GetAccountTracesPa func (c *Client) sendGetAccountTraces(ctx context.Context, params GetAccountTracesParams) (res *TraceIDs, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAccountTraces"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/traces"), } @@ -4616,14 +5776,14 @@ func (c *Client) sendGetAccountTraces(ctx context.Context, params GetAccountTrac 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...)) + c.duration.Record(ctx, 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, "GetAccountTraces", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountTracesOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -4707,6 +5867,40 @@ func (c *Client) sendGetAccountTraces(ctx context.Context, params GetAccountTrac return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountTracesOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -4734,11 +5928,6 @@ func (c *Client) GetAccounts(ctx context.Context, request OptGetAccountsReq, par } func (c *Client) sendGetAccounts(ctx context.Context, request OptGetAccountsReq, params GetAccountsParams) (res *Accounts, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getAccounts"), - semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/v2/accounts/_bulk"), - } // Validate request before sending. if err := func() error { if value, ok := request.Get(); ok { @@ -4755,20 +5944,25 @@ func (c *Client) sendGetAccounts(ctx context.Context, request OptGetAccountsReq, }(); err != nil { return res, errors.Wrap(err, "validate") } + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getAccounts"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/v2/accounts/_bulk"), + } // 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...)) + c.duration.Record(ctx, 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, "GetAccounts", + ctx, span := c.cfg.Tracer.Start(ctx, GetAccountsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -4819,6 +6013,40 @@ func (c *Client) sendGetAccounts(ctx context.Context, request OptGetAccountsReq, return res, errors.Wrap(err, "encode request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAccountsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -4848,7 +6076,7 @@ func (c *Client) GetAllAuctions(ctx context.Context, params GetAllAuctionsParams func (c *Client) sendGetAllAuctions(ctx context.Context, params GetAllAuctionsParams) (res *Auctions, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAllAuctions"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/dns/auctions"), } @@ -4857,14 +6085,14 @@ func (c *Client) sendGetAllAuctions(ctx context.Context, params GetAllAuctionsPa 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...)) + c.duration.Record(ctx, 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, "GetAllAuctions", + ctx, span := c.cfg.Tracer.Start(ctx, GetAllAuctionsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -4912,6 +6140,40 @@ func (c *Client) sendGetAllAuctions(ctx context.Context, params GetAllAuctionsPa return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAllAuctionsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -4941,7 +6203,7 @@ func (c *Client) GetAllRawShardsInfo(ctx context.Context, params GetAllRawShards func (c *Client) sendGetAllRawShardsInfo(ctx context.Context, params GetAllRawShardsInfoParams) (res *GetAllRawShardsInfoOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getAllRawShardsInfo"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_all_shards_info/{block_id}"), } @@ -4950,14 +6212,14 @@ func (c *Client) sendGetAllRawShardsInfo(ctx context.Context, params GetAllRawSh 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...)) + c.duration.Record(ctx, 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, "GetAllRawShardsInfo", + ctx, span := c.cfg.Tracer.Start(ctx, GetAllRawShardsInfoOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -5002,6 +6264,40 @@ func (c *Client) sendGetAllRawShardsInfo(ctx context.Context, params GetAllRawSh return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetAllRawShardsInfoOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -5031,7 +6327,7 @@ func (c *Client) GetBlockchainAccountTransactions(ctx context.Context, params Ge func (c *Client) sendGetBlockchainAccountTransactions(ctx context.Context, params GetBlockchainAccountTransactionsParams) (res *Transactions, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainAccountTransactions"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/accounts/{account_id}/transactions"), } @@ -5040,14 +6336,14 @@ func (c *Client) sendGetBlockchainAccountTransactions(ctx context.Context, param 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...)) + c.duration.Record(ctx, 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, "GetBlockchainAccountTransactions", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainAccountTransactionsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -5165,6 +6461,40 @@ func (c *Client) sendGetBlockchainAccountTransactions(ctx context.Context, param return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainAccountTransactionsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -5194,7 +6524,7 @@ func (c *Client) GetBlockchainBlock(ctx context.Context, params GetBlockchainBlo func (c *Client) sendGetBlockchainBlock(ctx context.Context, params GetBlockchainBlockParams) (res *BlockchainBlock, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainBlock"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/blocks/{block_id}"), } @@ -5203,14 +6533,14 @@ func (c *Client) sendGetBlockchainBlock(ctx context.Context, params GetBlockchai 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...)) + c.duration.Record(ctx, 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, "GetBlockchainBlock", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainBlockOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -5255,6 +6585,40 @@ func (c *Client) sendGetBlockchainBlock(ctx context.Context, params GetBlockchai return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainBlockOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -5284,7 +6648,7 @@ func (c *Client) GetBlockchainBlockTransactions(ctx context.Context, params GetB func (c *Client) sendGetBlockchainBlockTransactions(ctx context.Context, params GetBlockchainBlockTransactionsParams) (res *Transactions, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainBlockTransactions"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/blocks/{block_id}/transactions"), } @@ -5293,14 +6657,14 @@ func (c *Client) sendGetBlockchainBlockTransactions(ctx context.Context, params 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...)) + c.duration.Record(ctx, 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, "GetBlockchainBlockTransactions", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainBlockTransactionsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -5346,6 +6710,40 @@ func (c *Client) sendGetBlockchainBlockTransactions(ctx context.Context, params return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainBlockTransactionsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -5375,7 +6773,7 @@ func (c *Client) GetBlockchainConfig(ctx context.Context) (*BlockchainConfig, er func (c *Client) sendGetBlockchainConfig(ctx context.Context) (res *BlockchainConfig, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainConfig"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/config"), } @@ -5384,14 +6782,14 @@ func (c *Client) sendGetBlockchainConfig(ctx context.Context) (res *BlockchainCo 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...)) + c.duration.Record(ctx, 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, "GetBlockchainConfig", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainConfigOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -5418,6 +6816,40 @@ func (c *Client) sendGetBlockchainConfig(ctx context.Context) (res *BlockchainCo return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainConfigOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -5447,7 +6879,7 @@ func (c *Client) GetBlockchainConfigFromBlock(ctx context.Context, params GetBlo func (c *Client) sendGetBlockchainConfigFromBlock(ctx context.Context, params GetBlockchainConfigFromBlockParams) (res *BlockchainConfig, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainConfigFromBlock"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/masterchain/{masterchain_seqno}/config"), } @@ -5456,14 +6888,14 @@ func (c *Client) sendGetBlockchainConfigFromBlock(ctx context.Context, params Ge 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...)) + c.duration.Record(ctx, 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, "GetBlockchainConfigFromBlock", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainConfigFromBlockOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -5509,6 +6941,40 @@ func (c *Client) sendGetBlockchainConfigFromBlock(ctx context.Context, params Ge return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainConfigFromBlockOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -5540,7 +7006,7 @@ func (c *Client) GetBlockchainMasterchainBlocks(ctx context.Context, params GetB func (c *Client) sendGetBlockchainMasterchainBlocks(ctx context.Context, params GetBlockchainMasterchainBlocksParams) (res *BlockchainBlocks, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainMasterchainBlocks"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/masterchain/{masterchain_seqno}/blocks"), } @@ -5549,14 +7015,14 @@ func (c *Client) sendGetBlockchainMasterchainBlocks(ctx context.Context, params 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...)) + c.duration.Record(ctx, 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", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainMasterchainBlocksOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -5602,6 +7068,40 @@ func (c *Client) sendGetBlockchainMasterchainBlocks(ctx context.Context, params return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainMasterchainBlocksOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -5631,7 +7131,7 @@ func (c *Client) GetBlockchainMasterchainHead(ctx context.Context) (*BlockchainB func (c *Client) sendGetBlockchainMasterchainHead(ctx context.Context) (res *BlockchainBlock, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainMasterchainHead"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/masterchain-head"), } @@ -5640,14 +7140,14 @@ func (c *Client) sendGetBlockchainMasterchainHead(ctx context.Context) (res *Blo 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...)) + c.duration.Record(ctx, 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, "GetBlockchainMasterchainHead", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainMasterchainHeadOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -5674,6 +7174,40 @@ func (c *Client) sendGetBlockchainMasterchainHead(ctx context.Context) (res *Blo return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainMasterchainHeadOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -5703,7 +7237,7 @@ func (c *Client) GetBlockchainMasterchainShards(ctx context.Context, params GetB func (c *Client) sendGetBlockchainMasterchainShards(ctx context.Context, params GetBlockchainMasterchainShardsParams) (res *BlockchainBlockShards, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainMasterchainShards"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/masterchain/{masterchain_seqno}/shards"), } @@ -5712,14 +7246,14 @@ func (c *Client) sendGetBlockchainMasterchainShards(ctx context.Context, params 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...)) + c.duration.Record(ctx, 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, "GetBlockchainMasterchainShards", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainMasterchainShardsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -5765,6 +7299,40 @@ func (c *Client) sendGetBlockchainMasterchainShards(ctx context.Context, params return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainMasterchainShardsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -5796,7 +7364,7 @@ func (c *Client) GetBlockchainMasterchainTransactions(ctx context.Context, param func (c *Client) sendGetBlockchainMasterchainTransactions(ctx context.Context, params GetBlockchainMasterchainTransactionsParams) (res *Transactions, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainMasterchainTransactions"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/masterchain/{masterchain_seqno}/transactions"), } @@ -5805,14 +7373,14 @@ func (c *Client) sendGetBlockchainMasterchainTransactions(ctx context.Context, p 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...)) + c.duration.Record(ctx, 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", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainMasterchainTransactionsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -5858,6 +7426,40 @@ func (c *Client) sendGetBlockchainMasterchainTransactions(ctx context.Context, p return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainMasterchainTransactionsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -5887,7 +7489,7 @@ func (c *Client) GetBlockchainRawAccount(ctx context.Context, params GetBlockcha func (c *Client) sendGetBlockchainRawAccount(ctx context.Context, params GetBlockchainRawAccountParams) (res *BlockchainRawAccount, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainRawAccount"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/accounts/{account_id}"), } @@ -5896,14 +7498,14 @@ func (c *Client) sendGetBlockchainRawAccount(ctx context.Context, params GetBloc 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...)) + c.duration.Record(ctx, 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, "GetBlockchainRawAccount", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainRawAccountOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -5948,6 +7550,40 @@ func (c *Client) sendGetBlockchainRawAccount(ctx context.Context, params GetBloc return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainRawAccountOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -5977,7 +7613,7 @@ func (c *Client) GetBlockchainTransaction(ctx context.Context, params GetBlockch func (c *Client) sendGetBlockchainTransaction(ctx context.Context, params GetBlockchainTransactionParams) (res *Transaction, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainTransaction"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/transactions/{transaction_id}"), } @@ -5986,14 +7622,14 @@ func (c *Client) sendGetBlockchainTransaction(ctx context.Context, params GetBlo 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...)) + c.duration.Record(ctx, 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, "GetBlockchainTransaction", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainTransactionOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -6038,10 +7674,44 @@ func (c *Client) sendGetBlockchainTransaction(ctx context.Context, params GetBlo 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") + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainTransactionOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") } defer resp.Body.Close() @@ -6067,7 +7737,7 @@ func (c *Client) GetBlockchainTransactionByMessageHash(ctx context.Context, para func (c *Client) sendGetBlockchainTransactionByMessageHash(ctx context.Context, params GetBlockchainTransactionByMessageHashParams) (res *Transaction, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainTransactionByMessageHash"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/messages/{msg_id}/transaction"), } @@ -6076,14 +7746,14 @@ func (c *Client) sendGetBlockchainTransactionByMessageHash(ctx context.Context, 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...)) + c.duration.Record(ctx, 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, "GetBlockchainTransactionByMessageHash", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainTransactionByMessageHashOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -6129,6 +7799,40 @@ func (c *Client) sendGetBlockchainTransactionByMessageHash(ctx context.Context, return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainTransactionByMessageHashOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -6158,7 +7862,7 @@ func (c *Client) GetBlockchainValidators(ctx context.Context) (*Validators, erro func (c *Client) sendGetBlockchainValidators(ctx context.Context) (res *Validators, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getBlockchainValidators"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/validators"), } @@ -6167,14 +7871,14 @@ func (c *Client) sendGetBlockchainValidators(ctx context.Context) (res *Validato 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...)) + c.duration.Record(ctx, 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, "GetBlockchainValidators", + ctx, span := c.cfg.Tracer.Start(ctx, GetBlockchainValidatorsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -6201,6 +7905,40 @@ func (c *Client) sendGetBlockchainValidators(ctx context.Context) (res *Validato return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetBlockchainValidatorsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -6230,7 +7968,7 @@ func (c *Client) GetChartRates(ctx context.Context, params GetChartRatesParams) func (c *Client) sendGetChartRates(ctx context.Context, params GetChartRatesParams) (res *GetChartRatesOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getChartRates"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/rates/chart"), } @@ -6239,14 +7977,14 @@ func (c *Client) sendGetChartRates(ctx context.Context, params GetChartRatesPara 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...)) + c.duration.Record(ctx, 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, "GetChartRates", + ctx, span := c.cfg.Tracer.Start(ctx, GetChartRatesOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -6359,6 +8097,40 @@ func (c *Client) sendGetChartRates(ctx context.Context, params GetChartRatesPara return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetChartRatesOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -6388,7 +8160,7 @@ func (c *Client) GetDnsInfo(ctx context.Context, params GetDnsInfoParams) (*Doma func (c *Client) sendGetDnsInfo(ctx context.Context, params GetDnsInfoParams) (res *DomainInfo, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getDnsInfo"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/dns/{domain_name}"), } @@ -6397,14 +8169,14 @@ func (c *Client) sendGetDnsInfo(ctx context.Context, params GetDnsInfoParams) (r 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...)) + c.duration.Record(ctx, 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, "GetDnsInfo", + ctx, span := c.cfg.Tracer.Start(ctx, GetDnsInfoOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -6449,6 +8221,40 @@ func (c *Client) sendGetDnsInfo(ctx context.Context, params GetDnsInfoParams) (r return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetDnsInfoOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -6478,7 +8284,7 @@ func (c *Client) GetDomainBids(ctx context.Context, params GetDomainBidsParams) func (c *Client) sendGetDomainBids(ctx context.Context, params GetDomainBidsParams) (res *DomainBids, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getDomainBids"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/dns/{domain_name}/bids"), } @@ -6487,14 +8293,14 @@ func (c *Client) sendGetDomainBids(ctx context.Context, params GetDomainBidsPara 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...)) + c.duration.Record(ctx, 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, "GetDomainBids", + ctx, span := c.cfg.Tracer.Start(ctx, GetDomainBidsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -6540,6 +8346,40 @@ func (c *Client) sendGetDomainBids(ctx context.Context, params GetDomainBidsPara return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetDomainBidsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -6574,7 +8414,7 @@ func (c *Client) GetEvent(ctx context.Context, params GetEventParams) (*Event, e func (c *Client) sendGetEvent(ctx context.Context, params GetEventParams) (res *Event, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getEvent"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/events/{event_id}"), } @@ -6583,14 +8423,14 @@ func (c *Client) sendGetEvent(ctx context.Context, params GetEventParams) (res * 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...)) + c.duration.Record(ctx, 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, "GetEvent", + ctx, span := c.cfg.Tracer.Start(ctx, GetEventOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -6652,6 +8492,40 @@ func (c *Client) sendGetEvent(ctx context.Context, params GetEventParams) (res * } } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetEventOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -6668,22 +8542,21 @@ func (c *Client) sendGetEvent(ctx context.Context, params GetEventParams) (res * return result, nil } -// GetInscriptionOpTemplate invokes getInscriptionOpTemplate operation. +// GetExtraCurrencyInfo invokes getExtraCurrencyInfo operation. // -// Return comment for making operation with inscription. please don't use it if you don't know what -// you are doing. +// Get extra currency info by id. // -// GET /v2/experimental/inscriptions/op-template -func (c *Client) GetInscriptionOpTemplate(ctx context.Context, params GetInscriptionOpTemplateParams) (*GetInscriptionOpTemplateOK, error) { - res, err := c.sendGetInscriptionOpTemplate(ctx, params) +// GET /v2/extra-currency/{id} +func (c *Client) GetExtraCurrencyInfo(ctx context.Context, params GetExtraCurrencyInfoParams) (*EcPreview, error) { + res, err := c.sendGetExtraCurrencyInfo(ctx, params) return res, err } -func (c *Client) sendGetInscriptionOpTemplate(ctx context.Context, params GetInscriptionOpTemplateParams) (res *GetInscriptionOpTemplateOK, err error) { +func (c *Client) sendGetExtraCurrencyInfo(ctx context.Context, params GetExtraCurrencyInfoParams) (res *EcPreview, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getInscriptionOpTemplate"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/experimental/inscriptions/op-template"), + otelogen.OperationID("getExtraCurrencyInfo"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/extra-currency/{id}"), } // Run stopwatch. @@ -6691,14 +8564,14 @@ func (c *Client) sendGetInscriptionOpTemplate(ctx context.Context, params GetIns 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...)) + c.duration.Record(ctx, 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, "GetInscriptionOpTemplate", + ctx, span := c.cfg.Tracer.Start(ctx, GetExtraCurrencyInfoOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -6715,54 +8588,166 @@ func (c *Client) sendGetInscriptionOpTemplate(ctx context.Context, params GetIns stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) - var pathParts [1]string - pathParts[0] = "/v2/experimental/inscriptions/op-template" + var pathParts [2]string + pathParts[0] = "/v2/extra-currency/" + { + // Encode "id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.Int32ToString(params.ID)) + }(); 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 + } uri.AddPathParts(u, pathParts[:]...) - stage = "EncodeQueryParams" - q := uri.NewQueryEncoder() + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + { - // Encode "type" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "type", - Style: uri.QueryStyleForm, - Explode: true, + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetExtraCurrencyInfoOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } } - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - return e.EncodeValue(conv.StringToString(string(params.Type))) - }); err != nil { - return res, errors.Wrap(err, "encode query") + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied } } - { - // Encode "destination" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "destination", - Style: uri.QueryStyleForm, - Explode: true, + + 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 := decodeGetExtraCurrencyInfoResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetItemsFromCollection invokes getItemsFromCollection operation. +// +// Get NFT items from collection by collection address. +// +// GET /v2/nfts/collections/{account_id}/items +func (c *Client) GetItemsFromCollection(ctx context.Context, params GetItemsFromCollectionParams) (*NftItems, error) { + res, err := c.sendGetItemsFromCollection(ctx, params) + return res, err +} + +func (c *Client) sendGetItemsFromCollection(ctx context.Context, params GetItemsFromCollectionParams) (res *NftItems, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getItemsFromCollection"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/nfts/collections/{account_id}/items"), + } + + // 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(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, GetItemsFromCollectionOperation, + 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() + }() - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.Destination.Get(); ok { - return e.EncodeValue(conv.StringToString(val)) - } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode query") + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [3]string + pathParts[0] = "/v2/nfts/collections/" + { + // Encode "account_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "account_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.AccountID)) + }(); 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] = "/items" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() { - // Encode "comment" parameter. + // Encode "limit" parameter. cfg := uri.QueryParameterEncodingConfig{ - Name: "comment", + Name: "limit", Style: uri.QueryStyleForm, Explode: true, } if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.Comment.Get(); ok { - return e.EncodeValue(conv.StringToString(val)) + if val, ok := params.Limit.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) } return nil }); err != nil { @@ -6770,68 +8755,688 @@ func (c *Client) sendGetInscriptionOpTemplate(ctx context.Context, params GetIns } } { - // Encode "operation" parameter. + // Encode "offset" parameter. cfg := uri.QueryParameterEncodingConfig{ - Name: "operation", + Name: "offset", Style: uri.QueryStyleForm, Explode: true, } if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - return e.EncodeValue(conv.StringToString(string(params.Operation))) + if val, ok := params.Offset.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil }); err != nil { return res, errors.Wrap(err, "encode query") } } - { - // Encode "amount" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "amount", - Style: uri.QueryStyleForm, - Explode: true, - } + u.RawQuery = q.Values().Encode() - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - return e.EncodeValue(conv.StringToString(params.Amount)) - }); err != nil { - return res, errors.Wrap(err, "encode query") - } + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") } + { - // Encode "ticker" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "ticker", - Style: uri.QueryStyleForm, - Explode: true, + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetItemsFromCollectionOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } } - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - return e.EncodeValue(conv.StringToString(params.Ticker)) - }); err != nil { - return res, errors.Wrap(err, "encode query") + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied } } + + 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 := decodeGetItemsFromCollectionResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetJettonAccountHistoryByID invokes getJettonAccountHistoryByID operation. +// +// Get the transfer jetton history for account and jetton. +// +// GET /v2/jettons/{jetton_id}/accounts/{account_id}/history +func (c *Client) GetJettonAccountHistoryByID(ctx context.Context, params GetJettonAccountHistoryByIDParams) (*JettonOperations, error) { + res, err := c.sendGetJettonAccountHistoryByID(ctx, params) + return res, err +} + +func (c *Client) sendGetJettonAccountHistoryByID(ctx context.Context, params GetJettonAccountHistoryByIDParams) (res *JettonOperations, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getJettonAccountHistoryByID"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/jettons/{jetton_id}/accounts/{account_id}/history"), + } + + // 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(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, GetJettonAccountHistoryByIDOperation, + 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 [5]string + pathParts[0] = "/v2/jettons/" + { + // Encode "jetton_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "jetton_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.JettonID)) + }(); 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] = "/accounts/" + { + // Encode "account_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "account_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.AccountID)) + }(); err != nil { + return res, errors.Wrap(err, "encode path") + } + encoded, err := e.Result() + if err != nil { + return res, errors.Wrap(err, "encode path") + } + pathParts[3] = encoded + } + pathParts[4] = "/history" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() + { + // Encode "before_lt" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "before_lt", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.BeforeLt.Get(); ok { + return e.EncodeValue(conv.Int64ToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "limit" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "limit", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + return e.EncodeValue(conv.IntToString(params.Limit)) + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "start_date" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "start_date", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.StartDate.Get(); ok { + return e.EncodeValue(conv.Int64ToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "end_date" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "end_date", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.EndDate.Get(); ok { + return e.EncodeValue(conv.Int64ToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetJettonAccountHistoryByIDOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + + 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 := decodeGetJettonAccountHistoryByIDResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetJettonHolders invokes getJettonHolders operation. +// +// Get jetton's holders. +// +// GET /v2/jettons/{account_id}/holders +func (c *Client) GetJettonHolders(ctx context.Context, params GetJettonHoldersParams) (*JettonHolders, error) { + res, err := c.sendGetJettonHolders(ctx, params) + return res, err +} + +func (c *Client) sendGetJettonHolders(ctx context.Context, params GetJettonHoldersParams) (res *JettonHolders, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getJettonHolders"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/jettons/{account_id}/holders"), + } + + // 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(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, GetJettonHoldersOperation, + 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/jettons/" + { + // Encode "account_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "account_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.AccountID)) + }(); 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] = "/holders" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() + { + // Encode "limit" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "limit", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Limit.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "offset" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "offset", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Offset.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetJettonHoldersOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + + 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 := decodeGetJettonHoldersResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetJettonInfo invokes getJettonInfo operation. +// +// Get jetton metadata by jetton master address. +// +// GET /v2/jettons/{account_id} +func (c *Client) GetJettonInfo(ctx context.Context, params GetJettonInfoParams) (*JettonInfo, error) { + res, err := c.sendGetJettonInfo(ctx, params) + return res, err +} + +func (c *Client) sendGetJettonInfo(ctx context.Context, params GetJettonInfoParams) (res *JettonInfo, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getJettonInfo"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/jettons/{account_id}"), + } + + // 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(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, GetJettonInfoOperation, + 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 [2]string + pathParts[0] = "/v2/jettons/" + { + // Encode "account_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "account_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.AccountID)) + }(); 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 + } + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetJettonInfoOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + + 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 := decodeGetJettonInfoResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetJettonInfosByAddresses invokes getJettonInfosByAddresses operation. +// +// Get jetton metadata items by jetton master addresses. +// +// POST /v2/jettons/_bulk +func (c *Client) GetJettonInfosByAddresses(ctx context.Context, request OptGetJettonInfosByAddressesReq) (*Jettons, error) { + res, err := c.sendGetJettonInfosByAddresses(ctx, request) + return res, err +} + +func (c *Client) sendGetJettonInfosByAddresses(ctx context.Context, request OptGetJettonInfosByAddressesReq) (res *Jettons, err error) { + // Validate request before sending. + if err := func() error { + if value, ok := request.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getJettonInfosByAddresses"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/v2/jettons/_bulk"), + } + + // 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(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, GetJettonInfosByAddressesOperation, + 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/jettons/_bulk" + 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 := encodeGetJettonInfosByAddressesRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + { - // Encode "who" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "who", - Style: uri.QueryStyleForm, - Explode: true, + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetJettonInfosByAddressesOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } } - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - return e.EncodeValue(conv.StringToString(params.Who)) - }); err != nil { - return res, errors.Wrap(err, "encode query") + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied } } - u.RawQuery = q.Values().Encode() - - 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) @@ -6841,7 +9446,7 @@ func (c *Client) sendGetInscriptionOpTemplate(ctx context.Context, params GetIns defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetInscriptionOpTemplateResponse(resp) + result, err := decodeGetJettonInfosByAddressesResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6849,21 +9454,21 @@ func (c *Client) sendGetInscriptionOpTemplate(ctx context.Context, params GetIns return result, nil } -// GetItemsFromCollection invokes getItemsFromCollection operation. +// GetJettonTransferPayload invokes getJettonTransferPayload operation. // -// Get NFT items from collection by collection address. +// Get jetton's custom payload and state init required for transfer. // -// GET /v2/nfts/collections/{account_id}/items -func (c *Client) GetItemsFromCollection(ctx context.Context, params GetItemsFromCollectionParams) (*NftItems, error) { - res, err := c.sendGetItemsFromCollection(ctx, params) +// GET /v2/jettons/{jetton_id}/transfer/{account_id}/payload +func (c *Client) GetJettonTransferPayload(ctx context.Context, params GetJettonTransferPayloadParams) (*JettonTransferPayload, error) { + res, err := c.sendGetJettonTransferPayload(ctx, params) return res, err } -func (c *Client) sendGetItemsFromCollection(ctx context.Context, params GetItemsFromCollectionParams) (res *NftItems, err error) { +func (c *Client) sendGetJettonTransferPayload(ctx context.Context, params GetJettonTransferPayloadParams) (res *JettonTransferPayload, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getItemsFromCollection"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/nfts/collections/{account_id}/items"), + otelogen.OperationID("getJettonTransferPayload"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/jettons/{jetton_id}/transfer/{account_id}/payload"), } // Run stopwatch. @@ -6871,14 +9476,14 @@ func (c *Client) sendGetItemsFromCollection(ctx context.Context, params GetItems 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...)) + c.duration.Record(ctx, 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, "GetItemsFromCollection", + ctx, span := c.cfg.Tracer.Start(ctx, GetJettonTransferPayloadOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -6895,8 +9500,27 @@ func (c *Client) sendGetItemsFromCollection(ctx context.Context, params GetItems stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) - var pathParts [3]string - pathParts[0] = "/v2/nfts/collections/" + var pathParts [5]string + pathParts[0] = "/v2/jettons/" + { + // Encode "jetton_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "jetton_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.JettonID)) + }(); 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] = "/transfer/" { // Encode "account_id" parameter. e := uri.NewPathEncoder(uri.PathEncoderConfig{ @@ -6913,54 +9537,50 @@ func (c *Client) sendGetItemsFromCollection(ctx context.Context, params GetItems if err != nil { return res, errors.Wrap(err, "encode path") } - pathParts[1] = encoded + pathParts[3] = encoded } - pathParts[2] = "/items" + pathParts[4] = "/payload" uri.AddPathParts(u, pathParts[:]...) - stage = "EncodeQueryParams" - q := uri.NewQueryEncoder() - { - // Encode "limit" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "limit", - Style: uri.QueryStyleForm, - Explode: true, - } - - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.Limit.Get(); ok { - return e.EncodeValue(conv.IntToString(val)) - } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode query") - } + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") } + { - // Encode "offset" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "offset", - Style: uri.QueryStyleForm, - Explode: true, + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetJettonTransferPayloadOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } } - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.Offset.Get(); ok { - return e.EncodeValue(conv.IntToString(val)) + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode query") + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied } } - u.RawQuery = q.Values().Encode() - - 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) @@ -6970,7 +9590,7 @@ func (c *Client) sendGetItemsFromCollection(ctx context.Context, params GetItems defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetItemsFromCollectionResponse(resp) + result, err := decodeGetJettonTransferPayloadResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -6978,21 +9598,21 @@ func (c *Client) sendGetItemsFromCollection(ctx context.Context, params GetItems return result, nil } -// GetJettonHolders invokes getJettonHolders operation. +// GetJettons invokes getJettons operation. // -// Get jetton's holders. +// Get a list of all indexed jetton masters in the blockchain. // -// GET /v2/jettons/{account_id}/holders -func (c *Client) GetJettonHolders(ctx context.Context, params GetJettonHoldersParams) (*JettonHolders, error) { - res, err := c.sendGetJettonHolders(ctx, params) +// GET /v2/jettons +func (c *Client) GetJettons(ctx context.Context, params GetJettonsParams) (*Jettons, error) { + res, err := c.sendGetJettons(ctx, params) return res, err } -func (c *Client) sendGetJettonHolders(ctx context.Context, params GetJettonHoldersParams) (res *JettonHolders, err error) { +func (c *Client) sendGetJettons(ctx context.Context, params GetJettonsParams) (res *Jettons, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getJettonHolders"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/jettons/{account_id}/holders"), + otelogen.OperationID("getJettons"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/jettons"), } // Run stopwatch. @@ -7000,14 +9620,14 @@ func (c *Client) sendGetJettonHolders(ctx context.Context, params GetJettonHolde 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...)) + c.duration.Record(ctx, 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, "GetJettonHolders", + ctx, span := c.cfg.Tracer.Start(ctx, GetJettonsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -7024,27 +9644,8 @@ func (c *Client) sendGetJettonHolders(ctx context.Context, params GetJettonHolde stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) - var pathParts [3]string - pathParts[0] = "/v2/jettons/" - { - // Encode "account_id" parameter. - e := uri.NewPathEncoder(uri.PathEncoderConfig{ - Param: "account_id", - Style: uri.PathStyleSimple, - Explode: false, - }) - if err := func() error { - return e.EncodeValue(conv.StringToString(params.AccountID)) - }(); 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] = "/holders" + var pathParts [1]string + pathParts[0] = "/v2/jettons" uri.AddPathParts(u, pathParts[:]...) stage = "EncodeQueryParams" @@ -7059,7 +9660,7 @@ func (c *Client) sendGetJettonHolders(ctx context.Context, params GetJettonHolde if err := q.EncodeParam(cfg, func(e uri.Encoder) error { if val, ok := params.Limit.Get(); ok { - return e.EncodeValue(conv.IntToString(val)) + return e.EncodeValue(conv.Int32ToString(val)) } return nil }); err != nil { @@ -7076,7 +9677,7 @@ func (c *Client) sendGetJettonHolders(ctx context.Context, params GetJettonHolde if err := q.EncodeParam(cfg, func(e uri.Encoder) error { if val, ok := params.Offset.Get(); ok { - return e.EncodeValue(conv.IntToString(val)) + return e.EncodeValue(conv.Int32ToString(val)) } return nil }); err != nil { @@ -7091,6 +9692,40 @@ func (c *Client) sendGetJettonHolders(ctx context.Context, params GetJettonHolde return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetJettonsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -7099,7 +9734,7 @@ func (c *Client) sendGetJettonHolders(ctx context.Context, params GetJettonHolde defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetJettonHoldersResponse(resp) + result, err := decodeGetJettonsResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7107,21 +9742,21 @@ func (c *Client) sendGetJettonHolders(ctx context.Context, params GetJettonHolde return result, nil } -// GetJettonInfo invokes getJettonInfo operation. +// GetJettonsEvents invokes getJettonsEvents operation. // -// Get jetton metadata by jetton master address. +// Get only jetton transfers in the event. // -// GET /v2/jettons/{account_id} -func (c *Client) GetJettonInfo(ctx context.Context, params GetJettonInfoParams) (*JettonInfo, error) { - res, err := c.sendGetJettonInfo(ctx, params) +// GET /v2/events/{event_id}/jettons +func (c *Client) GetJettonsEvents(ctx context.Context, params GetJettonsEventsParams) (*Event, error) { + res, err := c.sendGetJettonsEvents(ctx, params) return res, err } -func (c *Client) sendGetJettonInfo(ctx context.Context, params GetJettonInfoParams) (res *JettonInfo, err error) { +func (c *Client) sendGetJettonsEvents(ctx context.Context, params GetJettonsEventsParams) (res *Event, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getJettonInfo"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/jettons/{account_id}"), + otelogen.OperationID("getJettonsEvents"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/events/{event_id}/jettons"), } // Run stopwatch. @@ -7129,14 +9764,14 @@ func (c *Client) sendGetJettonInfo(ctx context.Context, params GetJettonInfoPara 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...)) + c.duration.Record(ctx, 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, "GetJettonInfo", + ctx, span := c.cfg.Tracer.Start(ctx, GetJettonsEventsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -7153,17 +9788,17 @@ func (c *Client) sendGetJettonInfo(ctx context.Context, params GetJettonInfoPara stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) - var pathParts [2]string - pathParts[0] = "/v2/jettons/" + var pathParts [3]string + pathParts[0] = "/v2/events/" { - // Encode "account_id" parameter. + // Encode "event_id" parameter. e := uri.NewPathEncoder(uri.PathEncoderConfig{ - Param: "account_id", + Param: "event_id", Style: uri.PathStyleSimple, Explode: false, }) if err := func() error { - return e.EncodeValue(conv.StringToString(params.AccountID)) + return e.EncodeValue(conv.StringToString(params.EventID)) }(); err != nil { return res, errors.Wrap(err, "encode path") } @@ -7173,6 +9808,7 @@ func (c *Client) sendGetJettonInfo(ctx context.Context, params GetJettonInfoPara } pathParts[1] = encoded } + pathParts[2] = "/jettons" uri.AddPathParts(u, pathParts[:]...) stage = "EncodeRequest" @@ -7181,6 +9817,57 @@ func (c *Client) sendGetJettonInfo(ctx context.Context, params GetJettonInfoPara return res, errors.Wrap(err, "create request") } + stage = "EncodeHeaderParams" + h := uri.NewHeaderEncoder(r.Header) + { + cfg := uri.HeaderParameterEncodingConfig{ + Name: "Accept-Language", + Explode: false, + } + if err := h.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.AcceptLanguage.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode header") + } + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetJettonsEventsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -7189,7 +9876,7 @@ func (c *Client) sendGetJettonInfo(ctx context.Context, params GetJettonInfoPara defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetJettonInfoResponse(resp) + result, err := decodeGetJettonsEventsResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7197,21 +9884,21 @@ func (c *Client) sendGetJettonInfo(ctx context.Context, params GetJettonInfoPara return result, nil } -// GetJettonTransferPayload invokes getJettonTransferPayload operation. +// GetLibraryByHash invokes getLibraryByHash operation. // -// Get jetton's custom payload and state init required for transfer. +// Get library cell. // -// GET /v2/jettons/{jetton_id}/transfer/{account_id}/payload -func (c *Client) GetJettonTransferPayload(ctx context.Context, params GetJettonTransferPayloadParams) (*JettonTransferPayload, error) { - res, err := c.sendGetJettonTransferPayload(ctx, params) +// GET /v2/blockchain/libraries/{hash} +func (c *Client) GetLibraryByHash(ctx context.Context, params GetLibraryByHashParams) (*BlockchainLibrary, error) { + res, err := c.sendGetLibraryByHash(ctx, params) return res, err } -func (c *Client) sendGetJettonTransferPayload(ctx context.Context, params GetJettonTransferPayloadParams) (res *JettonTransferPayload, err error) { +func (c *Client) sendGetLibraryByHash(ctx context.Context, params GetLibraryByHashParams) (res *BlockchainLibrary, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getJettonTransferPayload"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/jettons/{jetton_id}/transfer/{account_id}/payload"), + otelogen.OperationID("getLibraryByHash"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/blockchain/libraries/{hash}"), } // Run stopwatch. @@ -7219,14 +9906,14 @@ func (c *Client) sendGetJettonTransferPayload(ctx context.Context, params GetJet 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...)) + c.duration.Record(ctx, 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, "GetJettonTransferPayload", + ctx, span := c.cfg.Tracer.Start(ctx, GetLibraryByHashOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -7237,42 +9924,23 @@ func (c *Client) sendGetJettonTransferPayload(ctx context.Context, params GetJet 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 [5]string - pathParts[0] = "/v2/jettons/" - { - // Encode "jetton_id" parameter. - e := uri.NewPathEncoder(uri.PathEncoderConfig{ - Param: "jetton_id", - Style: uri.PathStyleSimple, - Explode: false, - }) - if err := func() error { - return e.EncodeValue(conv.StringToString(params.JettonID)) - }(); 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] = "/transfer/" + } + span.End() + }() + + stage = "BuildURL" + u := uri.Clone(c.requestURL(ctx)) + var pathParts [2]string + pathParts[0] = "/v2/blockchain/libraries/" { - // Encode "account_id" parameter. + // Encode "hash" parameter. e := uri.NewPathEncoder(uri.PathEncoderConfig{ - Param: "account_id", + Param: "hash", Style: uri.PathStyleSimple, Explode: false, }) if err := func() error { - return e.EncodeValue(conv.StringToString(params.AccountID)) + return e.EncodeValue(conv.StringToString(params.Hash)) }(); err != nil { return res, errors.Wrap(err, "encode path") } @@ -7280,9 +9948,8 @@ func (c *Client) sendGetJettonTransferPayload(ctx context.Context, params GetJet if err != nil { return res, errors.Wrap(err, "encode path") } - pathParts[3] = encoded + pathParts[1] = encoded } - pathParts[4] = "/payload" uri.AddPathParts(u, pathParts[:]...) stage = "EncodeRequest" @@ -7291,6 +9958,40 @@ func (c *Client) sendGetJettonTransferPayload(ctx context.Context, params GetJet return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetLibraryByHashOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -7299,7 +10000,7 @@ func (c *Client) sendGetJettonTransferPayload(ctx context.Context, params GetJet defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetJettonTransferPayloadResponse(resp) + result, err := decodeGetLibraryByHashResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7307,21 +10008,21 @@ func (c *Client) sendGetJettonTransferPayload(ctx context.Context, params GetJet return result, nil } -// GetJettons invokes getJettons operation. +// GetMarketsRates invokes getMarketsRates operation. // -// Get a list of all indexed jetton masters in the blockchain. +// Get the TON price from markets. // -// GET /v2/jettons -func (c *Client) GetJettons(ctx context.Context, params GetJettonsParams) (*Jettons, error) { - res, err := c.sendGetJettons(ctx, params) +// GET /v2/rates/markets +func (c *Client) GetMarketsRates(ctx context.Context) (*GetMarketsRatesOK, error) { + res, err := c.sendGetMarketsRates(ctx) return res, err } -func (c *Client) sendGetJettons(ctx context.Context, params GetJettonsParams) (res *Jettons, err error) { +func (c *Client) sendGetMarketsRates(ctx context.Context) (res *GetMarketsRatesOK, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getJettons"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/jettons"), + otelogen.OperationID("getMarketsRates"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/rates/markets"), } // Run stopwatch. @@ -7329,14 +10030,14 @@ func (c *Client) sendGetJettons(ctx context.Context, params GetJettonsParams) (r 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...)) + c.duration.Record(ctx, 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, "GetJettons", + ctx, span := c.cfg.Tracer.Start(ctx, GetMarketsRatesOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -7354,52 +10055,48 @@ func (c *Client) sendGetJettons(ctx context.Context, params GetJettonsParams) (r stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) var pathParts [1]string - pathParts[0] = "/v2/jettons" + pathParts[0] = "/v2/rates/markets" uri.AddPathParts(u, pathParts[:]...) - stage = "EncodeQueryParams" - q := uri.NewQueryEncoder() - { - // Encode "limit" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "limit", - Style: uri.QueryStyleForm, - Explode: true, - } - - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.Limit.Get(); ok { - return e.EncodeValue(conv.Int32ToString(val)) - } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode query") - } + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") } + { - // Encode "offset" parameter. - cfg := uri.QueryParameterEncodingConfig{ - Name: "offset", - Style: uri.QueryStyleForm, - Explode: true, + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetMarketsRatesOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } } - if err := q.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.Offset.Get(); ok { - return e.EncodeValue(conv.Int32ToString(val)) + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode query") + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied } } - u.RawQuery = q.Values().Encode() - - 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) @@ -7409,7 +10106,7 @@ func (c *Client) sendGetJettons(ctx context.Context, params GetJettonsParams) (r defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetJettonsResponse(resp) + result, err := decodeGetMarketsRatesResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7417,21 +10114,21 @@ func (c *Client) sendGetJettons(ctx context.Context, params GetJettonsParams) (r return result, nil } -// GetJettonsEvents invokes getJettonsEvents operation. +// GetMultisigAccount invokes getMultisigAccount operation. // -// Get only jetton transfers in the event. +// Get multisig account info. // -// GET /v2/events/{event_id}/jettons -func (c *Client) GetJettonsEvents(ctx context.Context, params GetJettonsEventsParams) (*Event, error) { - res, err := c.sendGetJettonsEvents(ctx, params) +// GET /v2/multisig/{account_id} +func (c *Client) GetMultisigAccount(ctx context.Context, params GetMultisigAccountParams) (*Multisig, error) { + res, err := c.sendGetMultisigAccount(ctx, params) return res, err } -func (c *Client) sendGetJettonsEvents(ctx context.Context, params GetJettonsEventsParams) (res *Event, err error) { +func (c *Client) sendGetMultisigAccount(ctx context.Context, params GetMultisigAccountParams) (res *Multisig, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getJettonsEvents"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/events/{event_id}/jettons"), + otelogen.OperationID("getMultisigAccount"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/multisig/{account_id}"), } // Run stopwatch. @@ -7439,14 +10136,14 @@ func (c *Client) sendGetJettonsEvents(ctx context.Context, params GetJettonsEven 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...)) + c.duration.Record(ctx, 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, "GetJettonsEvents", + ctx, span := c.cfg.Tracer.Start(ctx, GetMultisigAccountOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -7463,17 +10160,17 @@ func (c *Client) sendGetJettonsEvents(ctx context.Context, params GetJettonsEven stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) - var pathParts [3]string - pathParts[0] = "/v2/events/" + var pathParts [2]string + pathParts[0] = "/v2/multisig/" { - // Encode "event_id" parameter. + // Encode "account_id" parameter. e := uri.NewPathEncoder(uri.PathEncoderConfig{ - Param: "event_id", + Param: "account_id", Style: uri.PathStyleSimple, Explode: false, }) if err := func() error { - return e.EncodeValue(conv.StringToString(params.EventID)) + return e.EncodeValue(conv.StringToString(params.AccountID)) }(); err != nil { return res, errors.Wrap(err, "encode path") } @@ -7483,7 +10180,6 @@ func (c *Client) sendGetJettonsEvents(ctx context.Context, params GetJettonsEven } pathParts[1] = encoded } - pathParts[2] = "/jettons" uri.AddPathParts(u, pathParts[:]...) stage = "EncodeRequest" @@ -7492,20 +10188,37 @@ func (c *Client) sendGetJettonsEvents(ctx context.Context, params GetJettonsEven return res, errors.Wrap(err, "create request") } - stage = "EncodeHeaderParams" - h := uri.NewHeaderEncoder(r.Header) { - cfg := uri.HeaderParameterEncodingConfig{ - Name: "Accept-Language", - Explode: false, + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetMultisigAccountOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } } - if err := h.EncodeParam(cfg, func(e uri.Encoder) error { - if val, ok := params.AcceptLanguage.Get(); ok { - return e.EncodeValue(conv.StringToString(val)) + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true } - return nil - }); err != nil { - return res, errors.Wrap(err, "encode header") + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied } } @@ -7517,7 +10230,7 @@ func (c *Client) sendGetJettonsEvents(ctx context.Context, params GetJettonsEven defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetJettonsEventsResponse(resp) + result, err := decodeGetMultisigAccountResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7525,21 +10238,21 @@ func (c *Client) sendGetJettonsEvents(ctx context.Context, params GetJettonsEven return result, nil } -// GetMarketsRates invokes getMarketsRates operation. +// GetMultisigOrder invokes getMultisigOrder operation. // -// Get the TON price from markets. +// Get multisig order. // -// GET /v2/rates/markets -func (c *Client) GetMarketsRates(ctx context.Context) (*GetMarketsRatesOK, error) { - res, err := c.sendGetMarketsRates(ctx) +// GET /v2/multisig/order/{account_id} +func (c *Client) GetMultisigOrder(ctx context.Context, params GetMultisigOrderParams) (*MultisigOrder, error) { + res, err := c.sendGetMultisigOrder(ctx, params) return res, err } -func (c *Client) sendGetMarketsRates(ctx context.Context) (res *GetMarketsRatesOK, err error) { +func (c *Client) sendGetMultisigOrder(ctx context.Context, params GetMultisigOrderParams) (res *MultisigOrder, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getMarketsRates"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/rates/markets"), + otelogen.OperationID("getMultisigOrder"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/multisig/order/{account_id}"), } // Run stopwatch. @@ -7547,14 +10260,14 @@ func (c *Client) sendGetMarketsRates(ctx context.Context) (res *GetMarketsRatesO 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...)) + c.duration.Record(ctx, 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, "GetMarketsRates", + ctx, span := c.cfg.Tracer.Start(ctx, GetMultisigOrderOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -7571,8 +10284,26 @@ func (c *Client) sendGetMarketsRates(ctx context.Context) (res *GetMarketsRatesO stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) - var pathParts [1]string - pathParts[0] = "/v2/rates/markets" + var pathParts [2]string + pathParts[0] = "/v2/multisig/order/" + { + // Encode "account_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "account_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.AccountID)) + }(); 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 + } uri.AddPathParts(u, pathParts[:]...) stage = "EncodeRequest" @@ -7581,6 +10312,40 @@ func (c *Client) sendGetMarketsRates(ctx context.Context) (res *GetMarketsRatesO return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetMultisigOrderOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -7589,7 +10354,7 @@ func (c *Client) sendGetMarketsRates(ctx context.Context) (res *GetMarketsRatesO defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetMarketsRatesResponse(resp) + result, err := decodeGetMultisigOrderResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7597,21 +10362,21 @@ func (c *Client) sendGetMarketsRates(ctx context.Context) (res *GetMarketsRatesO return result, nil } -// GetMultisigAccount invokes getMultisigAccount operation. +// GetNftCollection invokes getNftCollection operation. // -// Get multisig account info. +// Get NFT collection by collection address. // -// GET /v2/multisig/{account_id} -func (c *Client) GetMultisigAccount(ctx context.Context, params GetMultisigAccountParams) (*Multisig, error) { - res, err := c.sendGetMultisigAccount(ctx, params) +// GET /v2/nfts/collections/{account_id} +func (c *Client) GetNftCollection(ctx context.Context, params GetNftCollectionParams) (*NftCollection, error) { + res, err := c.sendGetNftCollection(ctx, params) return res, err } -func (c *Client) sendGetMultisigAccount(ctx context.Context, params GetMultisigAccountParams) (res *Multisig, err error) { +func (c *Client) sendGetNftCollection(ctx context.Context, params GetNftCollectionParams) (res *NftCollection, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getMultisigAccount"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/multisig/{account_id}"), + otelogen.OperationID("getNftCollection"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/nfts/collections/{account_id}"), } // Run stopwatch. @@ -7619,14 +10384,14 @@ func (c *Client) sendGetMultisigAccount(ctx context.Context, params GetMultisigA 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...)) + c.duration.Record(ctx, 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, "GetMultisigAccount", + ctx, span := c.cfg.Tracer.Start(ctx, GetNftCollectionOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -7644,7 +10409,7 @@ func (c *Client) sendGetMultisigAccount(ctx context.Context, params GetMultisigA stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) var pathParts [2]string - pathParts[0] = "/v2/multisig/" + pathParts[0] = "/v2/nfts/collections/" { // Encode "account_id" parameter. e := uri.NewPathEncoder(uri.PathEncoderConfig{ @@ -7671,6 +10436,40 @@ func (c *Client) sendGetMultisigAccount(ctx context.Context, params GetMultisigA return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetNftCollectionOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -7679,7 +10478,7 @@ func (c *Client) sendGetMultisigAccount(ctx context.Context, params GetMultisigA defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetMultisigAccountResponse(resp) + result, err := decodeGetNftCollectionResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7687,21 +10486,37 @@ func (c *Client) sendGetMultisigAccount(ctx context.Context, params GetMultisigA return result, nil } -// GetNftCollection invokes getNftCollection operation. +// GetNftCollectionItemsByAddresses invokes getNftCollectionItemsByAddresses operation. // -// Get NFT collection by collection address. +// Get NFT collection items by their addresses. // -// GET /v2/nfts/collections/{account_id} -func (c *Client) GetNftCollection(ctx context.Context, params GetNftCollectionParams) (*NftCollection, error) { - res, err := c.sendGetNftCollection(ctx, params) +// POST /v2/nfts/collections/_bulk +func (c *Client) GetNftCollectionItemsByAddresses(ctx context.Context, request OptGetNftCollectionItemsByAddressesReq) (*NftCollections, error) { + res, err := c.sendGetNftCollectionItemsByAddresses(ctx, request) return res, err } -func (c *Client) sendGetNftCollection(ctx context.Context, params GetNftCollectionParams) (res *NftCollection, err error) { +func (c *Client) sendGetNftCollectionItemsByAddresses(ctx context.Context, request OptGetNftCollectionItemsByAddressesReq) (res *NftCollections, err error) { + // Validate request before sending. + if err := func() error { + if value, ok := request.Get(); ok { + if err := func() error { + if err := value.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getNftCollection"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/nfts/collections/{account_id}"), + otelogen.OperationID("getNftCollectionItemsByAddresses"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/v2/nfts/collections/_bulk"), } // Run stopwatch. @@ -7709,14 +10524,14 @@ func (c *Client) sendGetNftCollection(ctx context.Context, params GetNftCollecti 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...)) + c.duration.Record(ctx, 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, "GetNftCollection", + ctx, span := c.cfg.Tracer.Start(ctx, GetNftCollectionItemsByAddressesOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -7733,33 +10548,52 @@ func (c *Client) sendGetNftCollection(ctx context.Context, params GetNftCollecti stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) - var pathParts [2]string - pathParts[0] = "/v2/nfts/collections/" - { - // Encode "account_id" parameter. - e := uri.NewPathEncoder(uri.PathEncoderConfig{ - Param: "account_id", - Style: uri.PathStyleSimple, - Explode: false, - }) - if err := func() error { - return e.EncodeValue(conv.StringToString(params.AccountID)) - }(); 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 - } + var pathParts [1]string + pathParts[0] = "/v2/nfts/collections/_bulk" uri.AddPathParts(u, pathParts[:]...) stage = "EncodeRequest" - r, err := ht.NewRequest(ctx, "GET", u) + r, err := ht.NewRequest(ctx, "POST", u) if err != nil { return res, errors.Wrap(err, "create request") } + if err := encodeGetNftCollectionItemsByAddressesRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetNftCollectionItemsByAddressesOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } stage = "SendRequest" resp, err := c.cfg.Client.Do(r) @@ -7769,7 +10603,7 @@ func (c *Client) sendGetNftCollection(ctx context.Context, params GetNftCollecti defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetNftCollectionResponse(resp) + result, err := decodeGetNftCollectionItemsByAddressesResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -7790,7 +10624,7 @@ func (c *Client) GetNftCollections(ctx context.Context, params GetNftCollections func (c *Client) sendGetNftCollections(ctx context.Context, params GetNftCollectionsParams) (res *NftCollections, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getNftCollections"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/nfts/collections"), } @@ -7799,14 +10633,14 @@ func (c *Client) sendGetNftCollections(ctx context.Context, params GetNftCollect 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...)) + c.duration.Record(ctx, 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, "GetNftCollections", + ctx, span := c.cfg.Tracer.Start(ctx, GetNftCollectionsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -7871,6 +10705,40 @@ func (c *Client) sendGetNftCollections(ctx context.Context, params GetNftCollect return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetNftCollectionsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -7889,7 +10757,9 @@ func (c *Client) sendGetNftCollections(ctx context.Context, params GetNftCollect // GetNftHistoryByID invokes getNftHistoryByID operation. // -// Get the transfer nfts history for account. +// Please use `getAccountNftHistory“ instead. +// +// Deprecated: schema marks this operation as deprecated. // // GET /v2/nfts/{account_id}/history func (c *Client) GetNftHistoryByID(ctx context.Context, params GetNftHistoryByIDParams) (*AccountEvents, error) { @@ -7900,7 +10770,7 @@ func (c *Client) GetNftHistoryByID(ctx context.Context, params GetNftHistoryByID func (c *Client) sendGetNftHistoryByID(ctx context.Context, params GetNftHistoryByIDParams) (res *AccountEvents, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getNftHistoryByID"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/nfts/{account_id}/history"), } @@ -7909,14 +10779,14 @@ func (c *Client) sendGetNftHistoryByID(ctx context.Context, params GetNftHistory 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...)) + c.duration.Record(ctx, 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, "GetNftHistoryByID", + ctx, span := c.cfg.Tracer.Start(ctx, GetNftHistoryByIDOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -8048,6 +10918,40 @@ func (c *Client) sendGetNftHistoryByID(ctx context.Context, params GetNftHistory } } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetNftHistoryByIDOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -8077,7 +10981,7 @@ func (c *Client) GetNftItemByAddress(ctx context.Context, params GetNftItemByAdd func (c *Client) sendGetNftItemByAddress(ctx context.Context, params GetNftItemByAddressParams) (res *NftItem, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getNftItemByAddress"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/nfts/{account_id}"), } @@ -8086,14 +10990,14 @@ func (c *Client) sendGetNftItemByAddress(ctx context.Context, params GetNftItemB 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...)) + c.duration.Record(ctx, 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, "GetNftItemByAddress", + ctx, span := c.cfg.Tracer.Start(ctx, GetNftItemByAddressOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -8138,6 +11042,40 @@ func (c *Client) sendGetNftItemByAddress(ctx context.Context, params GetNftItemB return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetNftItemByAddressOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -8165,11 +11103,6 @@ func (c *Client) GetNftItemsByAddresses(ctx context.Context, request OptGetNftIt } func (c *Client) sendGetNftItemsByAddresses(ctx context.Context, request OptGetNftItemsByAddressesReq) (res *NftItems, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getNftItemsByAddresses"), - semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/v2/nfts/_bulk"), - } // Validate request before sending. if err := func() error { if value, ok := request.Get(); ok { @@ -8186,20 +11119,346 @@ func (c *Client) sendGetNftItemsByAddresses(ctx context.Context, request OptGetN }(); err != nil { return res, errors.Wrap(err, "validate") } + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getNftItemsByAddresses"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/v2/nfts/_bulk"), + } + + // 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(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, GetNftItemsByAddressesOperation, + 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/nfts/_bulk" + 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 := encodeGetNftItemsByAddressesRequest(request, r); err != nil { + return res, errors.Wrap(err, "encode request") + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetNftItemsByAddressesOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + + 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 := decodeGetNftItemsByAddressesResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetOpenapiJson invokes getOpenapiJson operation. +// +// Get the openapi.json file. +// +// GET /v2/openapi.json +func (c *Client) GetOpenapiJson(ctx context.Context) (jx.Raw, error) { + res, err := c.sendGetOpenapiJson(ctx) + return res, err +} + +func (c *Client) sendGetOpenapiJson(ctx context.Context) (res jx.Raw, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getOpenapiJson"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/openapi.json"), + } + + // 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(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, GetOpenapiJsonOperation, + 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/openapi.json" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetOpenapiJsonOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + + 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 := decodeGetOpenapiJsonResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetOpenapiYml invokes getOpenapiYml operation. +// +// Get the openapi.yml file. +// +// GET /v2/openapi.yml +func (c *Client) GetOpenapiYml(ctx context.Context) (GetOpenapiYmlOK, error) { + res, err := c.sendGetOpenapiYml(ctx) + return res, err +} + +func (c *Client) sendGetOpenapiYml(ctx context.Context) (res GetOpenapiYmlOK, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getOpenapiYml"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/openapi.yml"), + } + + // 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(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, GetOpenapiYmlOperation, + 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/openapi.yml" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetOpenapiYmlOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + + 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 := decodeGetOpenapiYmlResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// GetOutMsgQueueSizes invokes getOutMsgQueueSizes operation. +// +// Get out msg queue sizes. +// +// GET /v2/liteserver/get_out_msg_queue_sizes +func (c *Client) GetOutMsgQueueSizes(ctx context.Context) (*GetOutMsgQueueSizesOK, error) { + res, err := c.sendGetOutMsgQueueSizes(ctx) + return res, err +} + +func (c *Client) sendGetOutMsgQueueSizes(ctx context.Context) (res *GetOutMsgQueueSizesOK, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getOutMsgQueueSizes"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/liteserver/get_out_msg_queue_sizes"), + } // 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...)) + c.duration.Record(ctx, 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, "GetNftItemsByAddresses", + ctx, span := c.cfg.Tracer.Start(ctx, GetOutMsgQueueSizesOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -8217,16 +11476,47 @@ func (c *Client) sendGetNftItemsByAddresses(ctx context.Context, request OptGetN stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) var pathParts [1]string - pathParts[0] = "/v2/nfts/_bulk" + pathParts[0] = "/v2/liteserver/get_out_msg_queue_sizes" uri.AddPathParts(u, pathParts[:]...) stage = "EncodeRequest" - r, err := ht.NewRequest(ctx, "POST", u) + r, err := ht.NewRequest(ctx, "GET", u) if err != nil { return res, errors.Wrap(err, "create request") } - if err := encodeGetNftItemsByAddressesRequest(request, r); err != nil { - return res, errors.Wrap(err, "encode request") + + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetOutMsgQueueSizesOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } } stage = "SendRequest" @@ -8237,7 +11527,7 @@ func (c *Client) sendGetNftItemsByAddresses(ctx context.Context, request OptGetN defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetNftItemsByAddressesResponse(resp) + result, err := decodeGetOutMsgQueueSizesResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8245,21 +11535,21 @@ func (c *Client) sendGetNftItemsByAddresses(ctx context.Context, request OptGetN return result, nil } -// GetOutMsgQueueSizes invokes getOutMsgQueueSizes operation. +// GetPurchaseHistory invokes getPurchaseHistory operation. // -// Get out msg queue sizes. +// Get history of purchases. // -// GET /v2/liteserver/get_out_msg_queue_sizes -func (c *Client) GetOutMsgQueueSizes(ctx context.Context) (*GetOutMsgQueueSizesOK, error) { - res, err := c.sendGetOutMsgQueueSizes(ctx) +// GET /v2/purchases/{account_id}/history +func (c *Client) GetPurchaseHistory(ctx context.Context, params GetPurchaseHistoryParams) (*AccountPurchases, error) { + res, err := c.sendGetPurchaseHistory(ctx, params) return res, err } -func (c *Client) sendGetOutMsgQueueSizes(ctx context.Context) (res *GetOutMsgQueueSizesOK, err error) { +func (c *Client) sendGetPurchaseHistory(ctx context.Context, params GetPurchaseHistoryParams) (res *AccountPurchases, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getOutMsgQueueSizes"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/liteserver/get_out_msg_queue_sizes"), + otelogen.OperationID("getPurchaseHistory"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/purchases/{account_id}/history"), } // Run stopwatch. @@ -8267,14 +11557,14 @@ func (c *Client) sendGetOutMsgQueueSizes(ctx context.Context) (res *GetOutMsgQue 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...)) + c.duration.Record(ctx, 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, "GetOutMsgQueueSizes", + ctx, span := c.cfg.Tracer.Start(ctx, GetPurchaseHistoryOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -8291,16 +11581,107 @@ func (c *Client) sendGetOutMsgQueueSizes(ctx context.Context) (res *GetOutMsgQue stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) - var pathParts [1]string - pathParts[0] = "/v2/liteserver/get_out_msg_queue_sizes" + var pathParts [3]string + pathParts[0] = "/v2/purchases/" + { + // Encode "account_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "account_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.AccountID)) + }(); 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] = "/history" uri.AddPathParts(u, pathParts[:]...) + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() + { + // Encode "before_lt" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "before_lt", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.BeforeLt.Get(); ok { + return e.EncodeValue(conv.Int64ToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "limit" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "limit", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Limit.Get(); ok { + return e.EncodeValue(conv.IntToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + u.RawQuery = q.Values().Encode() + stage = "EncodeRequest" r, err := ht.NewRequest(ctx, "GET", u) if err != nil { return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetPurchaseHistoryOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -8309,7 +11690,7 @@ func (c *Client) sendGetOutMsgQueueSizes(ctx context.Context) (res *GetOutMsgQue defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetOutMsgQueueSizesResponse(resp) + result, err := decodeGetPurchaseHistoryResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -8331,7 +11712,7 @@ func (c *Client) GetRates(ctx context.Context, params GetRatesParams) (*GetRates func (c *Client) sendGetRates(ctx context.Context, params GetRatesParams) (res *GetRatesOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRates"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/rates"), } @@ -8340,14 +11721,14 @@ func (c *Client) sendGetRates(ctx context.Context, params GetRatesParams) (res * 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...)) + c.duration.Record(ctx, 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, "GetRates", + ctx, span := c.cfg.Tracer.Start(ctx, GetRatesOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -8424,6 +11805,40 @@ func (c *Client) sendGetRates(ctx context.Context, params GetRatesParams) (res * return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRatesOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -8453,7 +11868,7 @@ func (c *Client) GetRawAccountState(ctx context.Context, params GetRawAccountSta func (c *Client) sendGetRawAccountState(ctx context.Context, params GetRawAccountStateParams) (res *GetRawAccountStateOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawAccountState"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_account_state/{account_id}"), } @@ -8462,14 +11877,14 @@ func (c *Client) sendGetRawAccountState(ctx context.Context, params GetRawAccoun 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...)) + c.duration.Record(ctx, 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, "GetRawAccountState", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawAccountStateOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -8535,6 +11950,40 @@ func (c *Client) sendGetRawAccountState(ctx context.Context, params GetRawAccoun return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawAccountStateOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -8564,7 +12013,7 @@ func (c *Client) GetRawBlockProof(ctx context.Context, params GetRawBlockProofPa func (c *Client) sendGetRawBlockProof(ctx context.Context, params GetRawBlockProofParams) (res *GetRawBlockProofOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawBlockProof"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_block_proof"), } @@ -8573,14 +12022,14 @@ func (c *Client) sendGetRawBlockProof(ctx context.Context, params GetRawBlockPro 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...)) + c.duration.Record(ctx, 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, "GetRawBlockProof", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawBlockProofOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -8656,6 +12105,40 @@ func (c *Client) sendGetRawBlockProof(ctx context.Context, params GetRawBlockPro return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawBlockProofOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -8685,7 +12168,7 @@ func (c *Client) GetRawBlockchainBlock(ctx context.Context, params GetRawBlockch func (c *Client) sendGetRawBlockchainBlock(ctx context.Context, params GetRawBlockchainBlockParams) (res *GetRawBlockchainBlockOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawBlockchainBlock"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_block/{block_id}"), } @@ -8694,14 +12177,14 @@ func (c *Client) sendGetRawBlockchainBlock(ctx context.Context, params GetRawBlo 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...)) + c.duration.Record(ctx, 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, "GetRawBlockchainBlock", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawBlockchainBlockOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -8746,6 +12229,40 @@ func (c *Client) sendGetRawBlockchainBlock(ctx context.Context, params GetRawBlo return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawBlockchainBlockOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -8775,7 +12292,7 @@ func (c *Client) GetRawBlockchainBlockHeader(ctx context.Context, params GetRawB func (c *Client) sendGetRawBlockchainBlockHeader(ctx context.Context, params GetRawBlockchainBlockHeaderParams) (res *GetRawBlockchainBlockHeaderOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawBlockchainBlockHeader"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_block_header/{block_id}"), } @@ -8784,14 +12301,14 @@ func (c *Client) sendGetRawBlockchainBlockHeader(ctx context.Context, params Get 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...)) + c.duration.Record(ctx, 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, "GetRawBlockchainBlockHeader", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawBlockchainBlockHeaderOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -8854,6 +12371,40 @@ func (c *Client) sendGetRawBlockchainBlockHeader(ctx context.Context, params Get return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawBlockchainBlockHeaderOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -8883,7 +12434,7 @@ func (c *Client) GetRawBlockchainBlockState(ctx context.Context, params GetRawBl func (c *Client) sendGetRawBlockchainBlockState(ctx context.Context, params GetRawBlockchainBlockStateParams) (res *GetRawBlockchainBlockStateOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawBlockchainBlockState"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_state/{block_id}"), } @@ -8892,14 +12443,14 @@ func (c *Client) sendGetRawBlockchainBlockState(ctx context.Context, params GetR 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...)) + c.duration.Record(ctx, 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, "GetRawBlockchainBlockState", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawBlockchainBlockStateOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -8944,6 +12495,40 @@ func (c *Client) sendGetRawBlockchainBlockState(ctx context.Context, params GetR return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawBlockchainBlockStateOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -8973,7 +12558,7 @@ func (c *Client) GetRawBlockchainConfig(ctx context.Context) (*RawBlockchainConf func (c *Client) sendGetRawBlockchainConfig(ctx context.Context) (res *RawBlockchainConfig, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawBlockchainConfig"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/config/raw"), } @@ -8982,14 +12567,14 @@ func (c *Client) sendGetRawBlockchainConfig(ctx context.Context) (res *RawBlockc 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...)) + c.duration.Record(ctx, 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, "GetRawBlockchainConfig", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawBlockchainConfigOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -9016,6 +12601,40 @@ func (c *Client) sendGetRawBlockchainConfig(ctx context.Context) (res *RawBlockc return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawBlockchainConfigOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -9045,7 +12664,7 @@ func (c *Client) GetRawBlockchainConfigFromBlock(ctx context.Context, params Get func (c *Client) sendGetRawBlockchainConfigFromBlock(ctx context.Context, params GetRawBlockchainConfigFromBlockParams) (res *RawBlockchainConfig, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawBlockchainConfigFromBlock"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/masterchain/{masterchain_seqno}/config/raw"), } @@ -9054,14 +12673,14 @@ func (c *Client) sendGetRawBlockchainConfigFromBlock(ctx context.Context, params 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...)) + c.duration.Record(ctx, 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, "GetRawBlockchainConfigFromBlock", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawBlockchainConfigFromBlockOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -9107,6 +12726,40 @@ func (c *Client) sendGetRawBlockchainConfigFromBlock(ctx context.Context, params return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawBlockchainConfigFromBlockOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -9136,7 +12789,7 @@ func (c *Client) GetRawConfig(ctx context.Context, params GetRawConfigParams) (* func (c *Client) sendGetRawConfig(ctx context.Context, params GetRawConfigParams) (res *GetRawConfigOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawConfig"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_config_all/{block_id}"), } @@ -9145,14 +12798,14 @@ func (c *Client) sendGetRawConfig(ctx context.Context, params GetRawConfigParams 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...)) + c.duration.Record(ctx, 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, "GetRawConfig", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawConfigOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -9215,6 +12868,40 @@ func (c *Client) sendGetRawConfig(ctx context.Context, params GetRawConfigParams return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawConfigOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -9244,7 +12931,7 @@ func (c *Client) GetRawListBlockTransactions(ctx context.Context, params GetRawL func (c *Client) sendGetRawListBlockTransactions(ctx context.Context, params GetRawListBlockTransactionsParams) (res *GetRawListBlockTransactionsOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawListBlockTransactions"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/list_block_transactions/{block_id}"), } @@ -9253,14 +12940,14 @@ func (c *Client) sendGetRawListBlockTransactions(ctx context.Context, params Get 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...)) + c.duration.Record(ctx, 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, "GetRawListBlockTransactions", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawListBlockTransactionsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -9371,6 +13058,40 @@ func (c *Client) sendGetRawListBlockTransactions(ctx context.Context, params Get return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawListBlockTransactionsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -9400,7 +13121,7 @@ func (c *Client) GetRawMasterchainInfo(ctx context.Context) (*GetRawMasterchainI func (c *Client) sendGetRawMasterchainInfo(ctx context.Context) (res *GetRawMasterchainInfoOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawMasterchainInfo"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_masterchain_info"), } @@ -9409,14 +13130,14 @@ func (c *Client) sendGetRawMasterchainInfo(ctx context.Context) (res *GetRawMast 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...)) + c.duration.Record(ctx, 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, "GetRawMasterchainInfo", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawMasterchainInfoOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -9443,6 +13164,40 @@ func (c *Client) sendGetRawMasterchainInfo(ctx context.Context) (res *GetRawMast return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawMasterchainInfoOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -9472,7 +13227,7 @@ func (c *Client) GetRawMasterchainInfoExt(ctx context.Context, params GetRawMast func (c *Client) sendGetRawMasterchainInfoExt(ctx context.Context, params GetRawMasterchainInfoExtParams) (res *GetRawMasterchainInfoExtOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawMasterchainInfoExt"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_masterchain_info_ext"), } @@ -9481,14 +13236,14 @@ func (c *Client) sendGetRawMasterchainInfoExt(ctx context.Context, params GetRaw 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...)) + c.duration.Record(ctx, 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, "GetRawMasterchainInfoExt", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawMasterchainInfoExtOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -9533,6 +13288,40 @@ func (c *Client) sendGetRawMasterchainInfoExt(ctx context.Context, params GetRaw return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawMasterchainInfoExtOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -9562,7 +13351,7 @@ func (c *Client) GetRawShardBlockProof(ctx context.Context, params GetRawShardBl func (c *Client) sendGetRawShardBlockProof(ctx context.Context, params GetRawShardBlockProofParams) (res *GetRawShardBlockProofOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawShardBlockProof"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_shard_block_proof/{block_id}"), } @@ -9571,14 +13360,14 @@ func (c *Client) sendGetRawShardBlockProof(ctx context.Context, params GetRawSha 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...)) + c.duration.Record(ctx, 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, "GetRawShardBlockProof", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawShardBlockProofOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -9623,6 +13412,40 @@ func (c *Client) sendGetRawShardBlockProof(ctx context.Context, params GetRawSha return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawShardBlockProofOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -9652,7 +13475,7 @@ func (c *Client) GetRawShardInfo(ctx context.Context, params GetRawShardInfoPara func (c *Client) sendGetRawShardInfo(ctx context.Context, params GetRawShardInfoParams) (res *GetRawShardInfoOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawShardInfo"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_shard_info/{block_id}"), } @@ -9661,14 +13484,14 @@ func (c *Client) sendGetRawShardInfo(ctx context.Context, params GetRawShardInfo 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...)) + c.duration.Record(ctx, 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, "GetRawShardInfo", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawShardInfoOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -9759,6 +13582,40 @@ func (c *Client) sendGetRawShardInfo(ctx context.Context, params GetRawShardInfo return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawShardInfoOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -9788,7 +13645,7 @@ func (c *Client) GetRawTime(ctx context.Context) (*GetRawTimeOK, error) { func (c *Client) sendGetRawTime(ctx context.Context) (res *GetRawTimeOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawTime"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_time"), } @@ -9797,14 +13654,14 @@ func (c *Client) sendGetRawTime(ctx context.Context) (res *GetRawTimeOK, err err 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...)) + c.duration.Record(ctx, 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, "GetRawTime", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawTimeOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -9831,6 +13688,40 @@ func (c *Client) sendGetRawTime(ctx context.Context) (res *GetRawTimeOK, err err return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawTimeOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -9860,7 +13751,7 @@ func (c *Client) GetRawTransactions(ctx context.Context, params GetRawTransactio func (c *Client) sendGetRawTransactions(ctx context.Context, params GetRawTransactionsParams) (res *GetRawTransactionsOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getRawTransactions"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/liteserver/get_transactions/{account_id}"), } @@ -9869,14 +13760,14 @@ func (c *Client) sendGetRawTransactions(ctx context.Context, params GetRawTransa 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...)) + c.duration.Record(ctx, 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, "GetRawTransactions", + ctx, span := c.cfg.Tracer.Start(ctx, GetRawTransactionsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -9967,6 +13858,40 @@ func (c *Client) sendGetRawTransactions(ctx context.Context, params GetRawTransa return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetRawTransactionsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -9996,7 +13921,7 @@ func (c *Client) GetReducedBlockchainBlocks(ctx context.Context, params GetReduc func (c *Client) sendGetReducedBlockchainBlocks(ctx context.Context, params GetReducedBlockchainBlocksParams) (res *ReducedBlocks, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getReducedBlockchainBlocks"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/blockchain/reduced/blocks"), } @@ -10005,14 +13930,14 @@ func (c *Client) sendGetReducedBlockchainBlocks(ctx context.Context, params GetR 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...)) + c.duration.Record(ctx, 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, "GetReducedBlockchainBlocks", + ctx, span := c.cfg.Tracer.Start(ctx, GetReducedBlockchainBlocksOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -10071,6 +13996,40 @@ func (c *Client) sendGetReducedBlockchainBlocks(ctx context.Context, params GetR return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetReducedBlockchainBlocksOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -10100,7 +14059,7 @@ func (c *Client) GetStakingPoolHistory(ctx context.Context, params GetStakingPoo func (c *Client) sendGetStakingPoolHistory(ctx context.Context, params GetStakingPoolHistoryParams) (res *GetStakingPoolHistoryOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getStakingPoolHistory"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/staking/pool/{account_id}/history"), } @@ -10109,14 +14068,14 @@ func (c *Client) sendGetStakingPoolHistory(ctx context.Context, params GetStakin 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...)) + c.duration.Record(ctx, 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, "GetStakingPoolHistory", + ctx, span := c.cfg.Tracer.Start(ctx, GetStakingPoolHistoryOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -10162,6 +14121,40 @@ func (c *Client) sendGetStakingPoolHistory(ctx context.Context, params GetStakin return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetStakingPoolHistoryOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -10191,7 +14184,7 @@ func (c *Client) GetStakingPoolInfo(ctx context.Context, params GetStakingPoolIn func (c *Client) sendGetStakingPoolInfo(ctx context.Context, params GetStakingPoolInfoParams) (res *GetStakingPoolInfoOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getStakingPoolInfo"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/staking/pool/{account_id}"), } @@ -10200,14 +14193,14 @@ func (c *Client) sendGetStakingPoolInfo(ctx context.Context, params GetStakingPo 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...)) + c.duration.Record(ctx, 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, "GetStakingPoolInfo", + ctx, span := c.cfg.Tracer.Start(ctx, GetStakingPoolInfoOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -10269,6 +14262,40 @@ func (c *Client) sendGetStakingPoolInfo(ctx context.Context, params GetStakingPo } } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetStakingPoolInfoOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -10298,7 +14325,7 @@ func (c *Client) GetStakingPools(ctx context.Context, params GetStakingPoolsPara func (c *Client) sendGetStakingPools(ctx context.Context, params GetStakingPoolsParams) (res *GetStakingPoolsOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getStakingPools"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/staking/pools"), } @@ -10307,14 +14334,14 @@ func (c *Client) sendGetStakingPools(ctx context.Context, params GetStakingPools 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...)) + c.duration.Record(ctx, 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, "GetStakingPools", + ctx, span := c.cfg.Tracer.Start(ctx, GetStakingPoolsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -10396,6 +14423,40 @@ func (c *Client) sendGetStakingPools(ctx context.Context, params GetStakingPools } } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetStakingPoolsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -10425,7 +14486,7 @@ func (c *Client) GetStorageProviders(ctx context.Context) (*GetStorageProvidersO func (c *Client) sendGetStorageProviders(ctx context.Context) (res *GetStorageProvidersOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getStorageProviders"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/storage/providers"), } @@ -10434,14 +14495,14 @@ func (c *Client) sendGetStorageProviders(ctx context.Context) (res *GetStoragePr 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...)) + c.duration.Record(ctx, 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, "GetStorageProviders", + ctx, span := c.cfg.Tracer.Start(ctx, GetStorageProvidersOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -10468,6 +14529,40 @@ func (c *Client) sendGetStorageProviders(ctx context.Context) (res *GetStoragePr return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetStorageProvidersOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -10497,7 +14592,7 @@ func (c *Client) GetTonConnectPayload(ctx context.Context) (*GetTonConnectPayloa func (c *Client) sendGetTonConnectPayload(ctx context.Context) (res *GetTonConnectPayloadOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getTonConnectPayload"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/tonconnect/payload"), } @@ -10506,14 +14601,14 @@ func (c *Client) sendGetTonConnectPayload(ctx context.Context) (res *GetTonConne 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...)) + c.duration.Record(ctx, 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, "GetTonConnectPayload", + ctx, span := c.cfg.Tracer.Start(ctx, GetTonConnectPayloadOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -10540,6 +14635,40 @@ func (c *Client) sendGetTonConnectPayload(ctx context.Context) (res *GetTonConne return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetTonConnectPayloadOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -10569,7 +14698,7 @@ func (c *Client) GetTrace(ctx context.Context, params GetTraceParams) (*Trace, e func (c *Client) sendGetTrace(ctx context.Context, params GetTraceParams) (res *Trace, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getTrace"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/traces/{trace_id}"), } @@ -10578,14 +14707,14 @@ func (c *Client) sendGetTrace(ctx context.Context, params GetTraceParams) (res * 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...)) + c.duration.Record(ctx, 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, "GetTrace", + ctx, span := c.cfg.Tracer.Start(ctx, GetTraceOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -10630,6 +14759,40 @@ func (c *Client) sendGetTrace(ctx context.Context, params GetTraceParams) (res * return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetTraceOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -10646,21 +14809,21 @@ func (c *Client) sendGetTrace(ctx context.Context, params GetTraceParams) (res * return result, nil } -// GetWalletBackup invokes getWalletBackup operation. +// GetWalletInfo invokes getWalletInfo operation. // -// Get backup info. +// Get human-friendly information about a wallet without low-level details. // -// GET /v2/wallet/backup -func (c *Client) GetWalletBackup(ctx context.Context, params GetWalletBackupParams) (*GetWalletBackupOK, error) { - res, err := c.sendGetWalletBackup(ctx, params) +// GET /v2/wallet/{account_id} +func (c *Client) GetWalletInfo(ctx context.Context, params GetWalletInfoParams) (*Wallet, error) { + res, err := c.sendGetWalletInfo(ctx, params) return res, err } -func (c *Client) sendGetWalletBackup(ctx context.Context, params GetWalletBackupParams) (res *GetWalletBackupOK, err error) { +func (c *Client) sendGetWalletInfo(ctx context.Context, params GetWalletInfoParams) (res *Wallet, err error) { otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("getWalletBackup"), - semconv.HTTPMethodKey.String("GET"), - semconv.HTTPRouteKey.String("/v2/wallet/backup"), + otelogen.OperationID("getWalletInfo"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/wallet/{account_id}"), } // Run stopwatch. @@ -10668,14 +14831,14 @@ func (c *Client) sendGetWalletBackup(ctx context.Context, params GetWalletBackup 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...)) + c.duration.Record(ctx, 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, "GetWalletBackup", + ctx, span := c.cfg.Tracer.Start(ctx, GetWalletInfoOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -10692,8 +14855,26 @@ func (c *Client) sendGetWalletBackup(ctx context.Context, params GetWalletBackup stage = "BuildURL" u := uri.Clone(c.requestURL(ctx)) - var pathParts [1]string - pathParts[0] = "/v2/wallet/backup" + var pathParts [2]string + pathParts[0] = "/v2/wallet/" + { + // Encode "account_id" parameter. + e := uri.NewPathEncoder(uri.PathEncoderConfig{ + Param: "account_id", + Style: uri.PathStyleSimple, + Explode: false, + }) + if err := func() error { + return e.EncodeValue(conv.StringToString(params.AccountID)) + }(); 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 + } uri.AddPathParts(u, pathParts[:]...) stage = "EncodeRequest" @@ -10702,17 +14883,37 @@ func (c *Client) sendGetWalletBackup(ctx context.Context, params GetWalletBackup return res, errors.Wrap(err, "create request") } - stage = "EncodeHeaderParams" - h := uri.NewHeaderEncoder(r.Header) { - cfg := uri.HeaderParameterEncodingConfig{ - Name: "X-TonConnect-Auth", - Explode: false, + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetWalletInfoOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } } - if err := h.EncodeParam(cfg, func(e uri.Encoder) error { - return e.EncodeValue(conv.StringToString(params.XTonConnectAuth)) - }); err != nil { - return res, errors.Wrap(err, "encode header") + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied } } @@ -10724,7 +14925,7 @@ func (c *Client) sendGetWalletBackup(ctx context.Context, params GetWalletBackup defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeGetWalletBackupResponse(resp) + result, err := decodeGetWalletInfoResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -10737,15 +14938,15 @@ func (c *Client) sendGetWalletBackup(ctx context.Context, params GetWalletBackup // Get wallets by public key. // // GET /v2/pubkeys/{public_key}/wallets -func (c *Client) GetWalletsByPublicKey(ctx context.Context, params GetWalletsByPublicKeyParams) (*Accounts, error) { +func (c *Client) GetWalletsByPublicKey(ctx context.Context, params GetWalletsByPublicKeyParams) (*Wallets, error) { res, err := c.sendGetWalletsByPublicKey(ctx, params) return res, err } -func (c *Client) sendGetWalletsByPublicKey(ctx context.Context, params GetWalletsByPublicKeyParams) (res *Accounts, err error) { +func (c *Client) sendGetWalletsByPublicKey(ctx context.Context, params GetWalletsByPublicKeyParams) (res *Wallets, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("getWalletsByPublicKey"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/pubkeys/{public_key}/wallets"), } @@ -10754,14 +14955,14 @@ func (c *Client) sendGetWalletsByPublicKey(ctx context.Context, params GetWallet 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...)) + c.duration.Record(ctx, 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, "GetWalletsByPublicKey", + ctx, span := c.cfg.Tracer.Start(ctx, GetWalletsByPublicKeyOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -10807,6 +15008,40 @@ func (c *Client) sendGetWalletsByPublicKey(ctx context.Context, params GetWallet return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, GetWalletsByPublicKeyOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -10836,7 +15071,7 @@ func (c *Client) ReindexAccount(ctx context.Context, params ReindexAccountParams func (c *Client) sendReindexAccount(ctx context.Context, params ReindexAccountParams) (res *ReindexAccountOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("reindexAccount"), - semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/v2/accounts/{account_id}/reindex"), } @@ -10845,14 +15080,14 @@ func (c *Client) sendReindexAccount(ctx context.Context, params ReindexAccountPa 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...)) + c.duration.Record(ctx, 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, "ReindexAccount", + ctx, span := c.cfg.Tracer.Start(ctx, ReindexAccountOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -10898,6 +15133,40 @@ func (c *Client) sendReindexAccount(ctx context.Context, params ReindexAccountPa return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, ReindexAccountOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -10927,7 +15196,7 @@ func (c *Client) SearchAccounts(ctx context.Context, params SearchAccountsParams func (c *Client) sendSearchAccounts(ctx context.Context, params SearchAccountsParams) (res *FoundAccounts, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("searchAccounts"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/accounts/search"), } @@ -10936,14 +15205,14 @@ func (c *Client) sendSearchAccounts(ctx context.Context, params SearchAccountsPa 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...)) + c.duration.Record(ctx, 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, "SearchAccounts", + ctx, span := c.cfg.Tracer.Start(ctx, SearchAccountsOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -10988,6 +15257,40 @@ func (c *Client) sendSearchAccounts(ctx context.Context, params SearchAccountsPa return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, SearchAccountsOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -11015,11 +15318,6 @@ func (c *Client) SendBlockchainMessage(ctx context.Context, request *SendBlockch } func (c *Client) sendSendBlockchainMessage(ctx context.Context, request *SendBlockchainMessageReq) (res *SendBlockchainMessageOK, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("sendBlockchainMessage"), - semconv.HTTPMethodKey.String("POST"), - semconv.HTTPRouteKey.String("/v2/blockchain/message"), - } // Validate request before sending. if err := func() error { if err := request.Validate(); err != nil { @@ -11029,20 +15327,25 @@ func (c *Client) sendSendBlockchainMessage(ctx context.Context, request *SendBlo }(); err != nil { return res, errors.Wrap(err, "validate") } + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("sendBlockchainMessage"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/v2/blockchain/message"), + } // 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...)) + c.duration.Record(ctx, 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, "SendBlockchainMessage", + ctx, span := c.cfg.Tracer.Start(ctx, SendBlockchainMessageOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -11072,6 +15375,40 @@ func (c *Client) sendSendBlockchainMessage(ctx context.Context, request *SendBlo return res, errors.Wrap(err, "encode request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, SendBlockchainMessageOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -11101,7 +15438,7 @@ func (c *Client) SendRawMessage(ctx context.Context, request *SendRawMessageReq) func (c *Client) sendSendRawMessage(ctx context.Context, request *SendRawMessageReq) (res *SendRawMessageOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("sendRawMessage"), - semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/v2/liteserver/send_message"), } @@ -11110,14 +15447,14 @@ func (c *Client) sendSendRawMessage(ctx context.Context, request *SendRawMessage 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...)) + c.duration.Record(ctx, 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, "SendRawMessage", + ctx, span := c.cfg.Tracer.Start(ctx, SendRawMessageOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -11147,92 +15484,37 @@ func (c *Client) sendSendRawMessage(ctx context.Context, request *SendRawMessage 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 := decodeSendRawMessageResponse(resp) - if err != nil { - return res, errors.Wrap(err, "decode response") - } - - return result, nil -} - -// SetWalletBackup invokes setWalletBackup operation. -// -// Set backup info. -// -// PUT /v2/wallet/backup -func (c *Client) SetWalletBackup(ctx context.Context, request SetWalletBackupReq, params SetWalletBackupParams) error { - _, err := c.sendSetWalletBackup(ctx, request, params) - return err -} - -func (c *Client) sendSetWalletBackup(ctx context.Context, request SetWalletBackupReq, params SetWalletBackupParams) (res *SetWalletBackupOK, err error) { - otelAttrs := []attribute.KeyValue{ - otelogen.OperationID("setWalletBackup"), - semconv.HTTPMethodKey.String("PUT"), - semconv.HTTPRouteKey.String("/v2/wallet/backup"), - } - - // 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, "SetWalletBackup", - 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/wallet/backup" - uri.AddPathParts(u, pathParts[:]...) - - stage = "EncodeRequest" - r, err := ht.NewRequest(ctx, "PUT", u) - if err != nil { - return res, errors.Wrap(err, "create request") - } - if err := encodeSetWalletBackupRequest(request, r); err != nil { - return res, errors.Wrap(err, "encode request") - } - - stage = "EncodeHeaderParams" - h := uri.NewHeaderEncoder(r.Header) { - cfg := uri.HeaderParameterEncodingConfig{ - Name: "X-TonConnect-Auth", - Explode: false, + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, SendRawMessageOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } } - if err := h.EncodeParam(cfg, func(e uri.Encoder) error { - return e.EncodeValue(conv.StringToString(params.XTonConnectAuth)) - }); err != nil { - return res, errors.Wrap(err, "encode header") + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied } } @@ -11244,7 +15526,7 @@ func (c *Client) sendSetWalletBackup(ctx context.Context, request SetWalletBacku defer resp.Body.Close() stage = "DecodeResponse" - result, err := decodeSetWalletBackupResponse(resp) + result, err := decodeSendRawMessageResponse(resp) if err != nil { return res, errors.Wrap(err, "decode response") } @@ -11265,7 +15547,7 @@ func (c *Client) Status(ctx context.Context) (*ServiceStatus, error) { func (c *Client) sendStatus(ctx context.Context) (res *ServiceStatus, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("status"), - semconv.HTTPMethodKey.String("GET"), + semconv.HTTPRequestMethodKey.String("GET"), semconv.HTTPRouteKey.String("/v2/status"), } @@ -11274,14 +15556,14 @@ func (c *Client) sendStatus(ctx context.Context) (res *ServiceStatus, err error) 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...)) + c.duration.Record(ctx, 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, "Status", + ctx, span := c.cfg.Tracer.Start(ctx, StatusOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -11308,6 +15590,40 @@ func (c *Client) sendStatus(ctx context.Context) (res *ServiceStatus, err error) return res, errors.Wrap(err, "create request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, StatusOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { @@ -11337,7 +15653,7 @@ func (c *Client) TonConnectProof(ctx context.Context, request *TonConnectProofRe func (c *Client) sendTonConnectProof(ctx context.Context, request *TonConnectProofReq) (res *TonConnectProofOK, err error) { otelAttrs := []attribute.KeyValue{ otelogen.OperationID("tonConnectProof"), - semconv.HTTPMethodKey.String("POST"), + semconv.HTTPRequestMethodKey.String("POST"), semconv.HTTPRouteKey.String("/v2/wallet/auth/proof"), } @@ -11346,14 +15662,14 @@ func (c *Client) sendTonConnectProof(ctx context.Context, request *TonConnectPro 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...)) + c.duration.Record(ctx, 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, "TonConnectProof", + ctx, span := c.cfg.Tracer.Start(ctx, TonConnectProofOperation, trace.WithAttributes(otelAttrs...), clientSpanKind, ) @@ -11383,6 +15699,40 @@ func (c *Client) sendTonConnectProof(ctx context.Context, request *TonConnectPro return res, errors.Wrap(err, "encode request") } + { + type bitset = [1]uint8 + var satisfied bitset + { + stage = "Security:BearerAuth" + switch err := c.securityBearerAuth(ctx, TonConnectProofOperation, r); { + case err == nil: // if NO error + satisfied[0] |= 1 << 0 + case errors.Is(err, ogenerrors.ErrSkipClientSecurity): + // Skip this security. + default: + return res, errors.Wrap(err, "security \"BearerAuth\"") + } + } + + if ok := func() bool { + nextRequirement: + for _, requirement := range []bitset{ + {0b00000001}, + {}, + } { + for i, mask := range requirement { + if satisfied[i]&mask != mask { + continue nextRequirement + } + } + return true + } + return false + }(); !ok { + return res, ogenerrors.ErrSecurityRequirementIsNotSatisfied + } + } + stage = "SendRequest" resp, err := c.cfg.Client.Do(r) if err != nil { diff --git a/oas_defaults_gen.go b/oas_defaults_gen.go index e27b127..29f1fd3 100644 --- a/oas_defaults_gen.go +++ b/oas_defaults_gen.go @@ -10,6 +10,18 @@ func (s *DomainBid) setDefaults() { } } +// setDefaults set default value of fields. +func (s *GaslessEstimateReq) setDefaults() { + { + val := bool(false) + s.ThrowErrorIfNotEnoughJettons.SetTo(val) + } + { + val := bool(false) + s.ReturnEmulation.SetTo(val) + } +} + // setDefaults set default value of fields. func (s *ServiceStatus) setDefaults() { { diff --git a/oas_json_gen.go b/oas_json_gen.go index e913ea4..b63c710 100644 --- a/oas_json_gen.go +++ b/oas_json_gen.go @@ -71,6 +71,16 @@ func (s *Account) encodeFields(e *jx.Encoder) { e.FieldStart("balance") e.Int64(s.Balance) } + { + if s.ExtraBalance != nil { + e.FieldStart("extra_balance") + e.ArrStart() + for _, elem := range s.ExtraBalance { + elem.Encode(e) + } + e.ArrEnd() + } + } { if s.CurrenciesBalance.Set { e.FieldStart("currencies_balance") @@ -139,20 +149,21 @@ func (s *Account) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfAccount = [13]string{ +var jsonFieldsNameOfAccount = [14]string{ 0: "address", 1: "balance", - 2: "currencies_balance", - 3: "last_activity", - 4: "status", - 5: "interfaces", - 6: "name", - 7: "is_scam", - 8: "icon", - 9: "memo_required", - 10: "get_methods", - 11: "is_suspended", - 12: "is_wallet", + 2: "extra_balance", + 3: "currencies_balance", + 4: "last_activity", + 5: "status", + 6: "interfaces", + 7: "name", + 8: "is_scam", + 9: "icon", + 10: "memo_required", + 11: "get_methods", + 12: "is_suspended", + 13: "is_wallet", } // Decode decodes Account from json. @@ -188,6 +199,23 @@ func (s *Account) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"balance\"") } + case "extra_balance": + if err := func() error { + s.ExtraBalance = make([]ExtraCurrency, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ExtraCurrency + if err := elem.Decode(d); err != nil { + return err + } + s.ExtraBalance = append(s.ExtraBalance, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"extra_balance\"") + } case "currencies_balance": if err := func() error { s.CurrenciesBalance.Reset() @@ -199,7 +227,7 @@ func (s *Account) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"currencies_balance\"") } case "last_activity": - requiredBitSet[0] |= 1 << 3 + requiredBitSet[0] |= 1 << 4 if err := func() error { v, err := d.Int64() s.LastActivity = int64(v) @@ -211,7 +239,7 @@ func (s *Account) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"last_activity\"") } case "status": - requiredBitSet[0] |= 1 << 4 + requiredBitSet[0] |= 1 << 5 if err := func() error { if err := s.Status.Decode(d); err != nil { return err @@ -280,7 +308,7 @@ func (s *Account) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"memo_required\"") } case "get_methods": - requiredBitSet[1] |= 1 << 2 + requiredBitSet[1] |= 1 << 3 if err := func() error { s.GetMethods = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -310,7 +338,7 @@ func (s *Account) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"is_suspended\"") } case "is_wallet": - requiredBitSet[1] |= 1 << 4 + requiredBitSet[1] |= 1 << 5 if err := func() error { v, err := d.Bool() s.IsWallet = bool(v) @@ -331,8 +359,8 @@ func (s *Account) Decode(d *jx.Decoder) error { // Validate required fields. var failures []validate.FieldError for i, mask := range [2]uint8{ - 0b00011011, - 0b00010100, + 0b00110011, + 0b00101000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -645,9 +673,13 @@ func (s *AccountEvent) encodeFields(e *jx.Encoder) { e.FieldStart("extra") e.Int64(s.Extra) } + { + e.FieldStart("progress") + e.Float32(s.Progress) + } } -var jsonFieldsNameOfAccountEvent = [8]string{ +var jsonFieldsNameOfAccountEvent = [9]string{ 0: "event_id", 1: "account", 2: "timestamp", @@ -656,6 +688,7 @@ var jsonFieldsNameOfAccountEvent = [8]string{ 5: "lt", 6: "in_progress", 7: "extra", + 8: "progress", } // Decode decodes AccountEvent from json. @@ -663,7 +696,7 @@ func (s *AccountEvent) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode AccountEvent to nil") } - var requiredBitSet [1]uint8 + var requiredBitSet [2]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -767,6 +800,18 @@ func (s *AccountEvent) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"extra\"") } + case "progress": + requiredBitSet[1] |= 1 << 0 + if err := func() error { + v, err := d.Float32() + s.Progress = float32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"progress\"") + } default: return d.Skip() } @@ -776,8 +821,9 @@ func (s *AccountEvent) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ + for i, mask := range [2]uint8{ 0b11111111, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -1059,6 +1105,129 @@ func (s *AccountInfoByStateInit) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *AccountPurchases) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *AccountPurchases) encodeFields(e *jx.Encoder) { + { + e.FieldStart("purchases") + e.ArrStart() + for _, elem := range s.Purchases { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("next_from") + e.Int64(s.NextFrom) + } +} + +var jsonFieldsNameOfAccountPurchases = [2]string{ + 0: "purchases", + 1: "next_from", +} + +// Decode decodes AccountPurchases from json. +func (s *AccountPurchases) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode AccountPurchases to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "purchases": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Purchases = make([]Purchase, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem Purchase + if err := elem.Decode(d); err != nil { + return err + } + s.Purchases = append(s.Purchases, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"purchases\"") + } + case "next_from": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int64() + s.NextFrom = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"next_from\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode AccountPurchases") + } + // 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(jsonFieldsNameOfAccountPurchases) { + name = jsonFieldsNameOfAccountPurchases[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 *AccountPurchases) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *AccountPurchases) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *AccountStaking) Encode(e *jx.Encoder) { e.ObjStart() @@ -1666,6 +1835,12 @@ func (s *Action) encodeFields(e *jx.Encoder) { s.TonTransfer.Encode(e) } } + { + if s.ExtraCurrencyTransfer.Set { + e.FieldStart("ExtraCurrencyTransfer") + s.ExtraCurrencyTransfer.Encode(e) + } + } { if s.ContractDeploy.Set { e.FieldStart("ContractDeploy") @@ -1769,15 +1944,51 @@ func (s *Action) encodeFields(e *jx.Encoder) { } } { - if s.InscriptionTransfer.Set { - e.FieldStart("InscriptionTransfer") - s.InscriptionTransfer.Encode(e) + if s.Purchase.Set { + e.FieldStart("Purchase") + s.Purchase.Encode(e) + } + } + { + if s.AddExtension.Set { + e.FieldStart("AddExtension") + s.AddExtension.Encode(e) + } + } + { + if s.RemoveExtension.Set { + e.FieldStart("RemoveExtension") + s.RemoveExtension.Encode(e) + } + } + { + if s.SetSignatureAllowedAction.Set { + e.FieldStart("SetSignatureAllowedAction") + s.SetSignatureAllowedAction.Encode(e) } } { - if s.InscriptionMint.Set { - e.FieldStart("InscriptionMint") - s.InscriptionMint.Encode(e) + if s.GasRelay.Set { + e.FieldStart("GasRelay") + s.GasRelay.Encode(e) + } + } + { + if s.DepositTokenStake.Set { + e.FieldStart("DepositTokenStake") + s.DepositTokenStake.Encode(e) + } + } + { + if s.WithdrawTokenStakeRequest.Set { + e.FieldStart("WithdrawTokenStakeRequest") + s.WithdrawTokenStakeRequest.Encode(e) + } + } + { + if s.LiquidityDeposit.Set { + e.FieldStart("LiquidityDeposit") + s.LiquidityDeposit.Encode(e) } } { @@ -1794,31 +2005,38 @@ func (s *Action) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfAction = [24]string{ +var jsonFieldsNameOfAction = [31]string{ 0: "type", 1: "status", 2: "TonTransfer", - 3: "ContractDeploy", - 4: "JettonTransfer", - 5: "JettonBurn", - 6: "JettonMint", - 7: "NftItemTransfer", - 8: "Subscribe", - 9: "UnSubscribe", - 10: "AuctionBid", - 11: "NftPurchase", - 12: "DepositStake", - 13: "WithdrawStake", - 14: "WithdrawStakeRequest", - 15: "ElectionsDepositStake", - 16: "ElectionsRecoverStake", - 17: "JettonSwap", - 18: "SmartContractExec", - 19: "DomainRenew", - 20: "InscriptionTransfer", - 21: "InscriptionMint", - 22: "simple_preview", - 23: "base_transactions", + 3: "ExtraCurrencyTransfer", + 4: "ContractDeploy", + 5: "JettonTransfer", + 6: "JettonBurn", + 7: "JettonMint", + 8: "NftItemTransfer", + 9: "Subscribe", + 10: "UnSubscribe", + 11: "AuctionBid", + 12: "NftPurchase", + 13: "DepositStake", + 14: "WithdrawStake", + 15: "WithdrawStakeRequest", + 16: "ElectionsDepositStake", + 17: "ElectionsRecoverStake", + 18: "JettonSwap", + 19: "SmartContractExec", + 20: "DomainRenew", + 21: "Purchase", + 22: "AddExtension", + 23: "RemoveExtension", + 24: "SetSignatureAllowedAction", + 25: "GasRelay", + 26: "DepositTokenStake", + 27: "WithdrawTokenStakeRequest", + 28: "LiquidityDeposit", + 29: "simple_preview", + 30: "base_transactions", } // Decode decodes Action from json. @@ -1826,7 +2044,7 @@ func (s *Action) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode Action to nil") } - var requiredBitSet [3]uint8 + var requiredBitSet [4]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -1860,6 +2078,16 @@ func (s *Action) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"TonTransfer\"") } + case "ExtraCurrencyTransfer": + if err := func() error { + s.ExtraCurrencyTransfer.Reset() + if err := s.ExtraCurrencyTransfer.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ExtraCurrencyTransfer\"") + } case "ContractDeploy": if err := func() error { s.ContractDeploy.Reset() @@ -2030,28 +2258,88 @@ func (s *Action) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"DomainRenew\"") } - case "InscriptionTransfer": + case "Purchase": + if err := func() error { + s.Purchase.Reset() + if err := s.Purchase.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"Purchase\"") + } + case "AddExtension": + if err := func() error { + s.AddExtension.Reset() + if err := s.AddExtension.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"AddExtension\"") + } + case "RemoveExtension": + if err := func() error { + s.RemoveExtension.Reset() + if err := s.RemoveExtension.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"RemoveExtension\"") + } + case "SetSignatureAllowedAction": + if err := func() error { + s.SetSignatureAllowedAction.Reset() + if err := s.SetSignatureAllowedAction.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"SetSignatureAllowedAction\"") + } + case "GasRelay": if err := func() error { - s.InscriptionTransfer.Reset() - if err := s.InscriptionTransfer.Decode(d); err != nil { + s.GasRelay.Reset() + if err := s.GasRelay.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"InscriptionTransfer\"") + return errors.Wrap(err, "decode field \"GasRelay\"") } - case "InscriptionMint": + case "DepositTokenStake": if err := func() error { - s.InscriptionMint.Reset() - if err := s.InscriptionMint.Decode(d); err != nil { + s.DepositTokenStake.Reset() + if err := s.DepositTokenStake.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"InscriptionMint\"") + return errors.Wrap(err, "decode field \"DepositTokenStake\"") + } + case "WithdrawTokenStakeRequest": + if err := func() error { + s.WithdrawTokenStakeRequest.Reset() + if err := s.WithdrawTokenStakeRequest.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"WithdrawTokenStakeRequest\"") + } + case "LiquidityDeposit": + if err := func() error { + s.LiquidityDeposit.Reset() + if err := s.LiquidityDeposit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"LiquidityDeposit\"") } case "simple_preview": - requiredBitSet[2] |= 1 << 6 + requiredBitSet[3] |= 1 << 5 if err := func() error { if err := s.SimplePreview.Decode(d); err != nil { return err @@ -2061,7 +2349,7 @@ func (s *Action) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"simple_preview\"") } case "base_transactions": - requiredBitSet[2] |= 1 << 7 + requiredBitSet[3] |= 1 << 6 if err := func() error { s.BaseTransactions = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -2089,10 +2377,11 @@ func (s *Action) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [3]uint8{ + for i, mask := range [4]uint8{ 0b00000011, 0b00000000, - 0b11000000, + 0b00000000, + 0b01100000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -2585,6 +2874,10 @@ func (s *ActionType) Decode(d *jx.Decoder) error { switch ActionType(v) { case ActionTypeTonTransfer: *s = ActionTypeTonTransfer + case ActionTypeExtraCurrencyTransfer: + *s = ActionTypeExtraCurrencyTransfer + case ActionTypeContractDeploy: + *s = ActionTypeContractDeploy case ActionTypeJettonTransfer: *s = ActionTypeJettonTransfer case ActionTypeJettonBurn: @@ -2593,8 +2886,6 @@ func (s *ActionType) Decode(d *jx.Decoder) error { *s = ActionTypeJettonMint case ActionTypeNftItemTransfer: *s = ActionTypeNftItemTransfer - case ActionTypeContractDeploy: - *s = ActionTypeContractDeploy case ActionTypeSubscribe: *s = ActionTypeSubscribe case ActionTypeUnSubscribe: @@ -2609,20 +2900,32 @@ func (s *ActionType) Decode(d *jx.Decoder) error { *s = ActionTypeWithdrawStake case ActionTypeWithdrawStakeRequest: *s = ActionTypeWithdrawStakeRequest + case ActionTypeElectionsDepositStake: + *s = ActionTypeElectionsDepositStake + case ActionTypeElectionsRecoverStake: + *s = ActionTypeElectionsRecoverStake case ActionTypeJettonSwap: *s = ActionTypeJettonSwap case ActionTypeSmartContractExec: *s = ActionTypeSmartContractExec - case ActionTypeElectionsRecoverStake: - *s = ActionTypeElectionsRecoverStake - case ActionTypeElectionsDepositStake: - *s = ActionTypeElectionsDepositStake case ActionTypeDomainRenew: *s = ActionTypeDomainRenew - case ActionTypeInscriptionTransfer: - *s = ActionTypeInscriptionTransfer - case ActionTypeInscriptionMint: - *s = ActionTypeInscriptionMint + case ActionTypePurchase: + *s = ActionTypePurchase + case ActionTypeAddExtension: + *s = ActionTypeAddExtension + case ActionTypeRemoveExtension: + *s = ActionTypeRemoveExtension + case ActionTypeSetSignatureAllowedAction: + *s = ActionTypeSetSignatureAllowedAction + case ActionTypeGasRelay: + *s = ActionTypeGasRelay + case ActionTypeDepositTokenStake: + *s = ActionTypeDepositTokenStake + case ActionTypeWithdrawTokenStakeRequest: + *s = ActionTypeWithdrawTokenStakeRequest + case ActionTypeLiquidityDeposit: + *s = ActionTypeLiquidityDeposit case ActionTypeUnknown: *s = ActionTypeUnknown default: @@ -2645,6 +2948,117 @@ func (s *ActionType) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *AddExtensionAction) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *AddExtensionAction) encodeFields(e *jx.Encoder) { + { + e.FieldStart("wallet") + s.Wallet.Encode(e) + } + { + e.FieldStart("extension") + e.Str(s.Extension) + } +} + +var jsonFieldsNameOfAddExtensionAction = [2]string{ + 0: "wallet", + 1: "extension", +} + +// Decode decodes AddExtensionAction from json. +func (s *AddExtensionAction) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode AddExtensionAction to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "wallet": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Wallet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet\"") + } + case "extension": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Extension = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"extension\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode AddExtensionAction") + } + // 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(jsonFieldsNameOfAddExtensionAction) { + name = jsonFieldsNameOfAddExtensionAction[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 *AddExtensionAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *AddExtensionAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *AddressParseOK) Encode(e *jx.Encoder) { e.ObjStart() @@ -4530,6 +4944,12 @@ func (s *BlockchainAccountInspect) encodeFields(e *jx.Encoder) { e.FieldStart("code") e.Str(s.Code) } + { + if s.DisassembledCode.Set { + e.FieldStart("disassembled_code") + s.DisassembledCode.Encode(e) + } + } { e.FieldStart("code_hash") e.Str(s.CodeHash) @@ -4543,18 +4963,24 @@ func (s *BlockchainAccountInspect) encodeFields(e *jx.Encoder) { e.ArrEnd() } { - if s.Compiler.Set { - e.FieldStart("compiler") - s.Compiler.Encode(e) + e.FieldStart("compiler") + s.Compiler.Encode(e) + } + { + if s.Source.Set { + e.FieldStart("source") + s.Source.Encode(e) } } } -var jsonFieldsNameOfBlockchainAccountInspect = [4]string{ +var jsonFieldsNameOfBlockchainAccountInspect = [6]string{ 0: "code", - 1: "code_hash", - 2: "methods", - 3: "compiler", + 1: "disassembled_code", + 2: "code_hash", + 3: "methods", + 4: "compiler", + 5: "source", } // Decode decodes BlockchainAccountInspect from json. @@ -4578,8 +5004,18 @@ func (s *BlockchainAccountInspect) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"code\"") } + case "disassembled_code": + if err := func() error { + s.DisassembledCode.Reset() + if err := s.DisassembledCode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"disassembled_code\"") + } case "code_hash": - requiredBitSet[0] |= 1 << 1 + requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() s.CodeHash = string(v) @@ -4591,11 +5027,11 @@ func (s *BlockchainAccountInspect) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"code_hash\"") } case "methods": - requiredBitSet[0] |= 1 << 2 + requiredBitSet[0] |= 1 << 3 if err := func() error { - s.Methods = make([]BlockchainAccountInspectMethodsItem, 0) + s.Methods = make([]Method, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem BlockchainAccountInspectMethodsItem + var elem Method if err := elem.Decode(d); err != nil { return err } @@ -4609,8 +5045,8 @@ func (s *BlockchainAccountInspect) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"methods\"") } case "compiler": + requiredBitSet[0] |= 1 << 4 if err := func() error { - s.Compiler.Reset() if err := s.Compiler.Decode(d); err != nil { return err } @@ -4618,6 +5054,16 @@ func (s *BlockchainAccountInspect) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"compiler\"") } + case "source": + if err := func() error { + s.Source.Reset() + if err := s.Source.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"source\"") + } default: return d.Skip() } @@ -4628,7 +5074,7 @@ func (s *BlockchainAccountInspect) Decode(d *jx.Decoder) error { // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b00011101, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -4692,6 +5138,10 @@ func (s *BlockchainAccountInspectCompiler) Decode(d *jx.Decoder) error { switch BlockchainAccountInspectCompiler(v) { case BlockchainAccountInspectCompilerFunc: *s = BlockchainAccountInspectCompilerFunc + case BlockchainAccountInspectCompilerFift: + *s = BlockchainAccountInspectCompilerFift + case BlockchainAccountInspectCompilerTact: + *s = BlockchainAccountInspectCompilerTact default: *s = BlockchainAccountInspectCompiler(v) } @@ -4712,119 +5162,6 @@ func (s *BlockchainAccountInspectCompiler) UnmarshalJSON(data []byte) error { return s.Decode(d) } -// Encode implements json.Marshaler. -func (s *BlockchainAccountInspectMethodsItem) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *BlockchainAccountInspectMethodsItem) encodeFields(e *jx.Encoder) { - { - e.FieldStart("id") - e.Int64(s.ID) - } - { - e.FieldStart("method") - e.Str(s.Method) - } -} - -var jsonFieldsNameOfBlockchainAccountInspectMethodsItem = [2]string{ - 0: "id", - 1: "method", -} - -// Decode decodes BlockchainAccountInspectMethodsItem from json. -func (s *BlockchainAccountInspectMethodsItem) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode BlockchainAccountInspectMethodsItem 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 "method": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Str() - s.Method = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"method\"") - } - default: - return d.Skip() - } - return nil - }); err != nil { - return errors.Wrap(err, "decode BlockchainAccountInspectMethodsItem") - } - // 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(jsonFieldsNameOfBlockchainAccountInspectMethodsItem) { - name = jsonFieldsNameOfBlockchainAccountInspectMethodsItem[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 *BlockchainAccountInspectMethodsItem) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *BlockchainAccountInspectMethodsItem) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - // Encode implements json.Marshaler. func (s *BlockchainBlock) Encode(e *jx.Encoder) { e.ObjStart() @@ -5975,6 +6312,12 @@ func (s *BlockchainConfig) encodeFields(e *jx.Encoder) { e.FieldStart("44") s.R44.Encode(e) } + { + if s.R45.Set { + e.FieldStart("45") + s.R45.Encode(e) + } + } { if s.R71.Set { e.FieldStart("71") @@ -6013,7 +6356,7 @@ func (s *BlockchainConfig) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfBlockchainConfig = [44]string{ +var jsonFieldsNameOfBlockchainConfig = [45]string{ 0: "raw", 1: "0", 2: "1", @@ -6052,12 +6395,13 @@ var jsonFieldsNameOfBlockchainConfig = [44]string{ 35: "40", 36: "43", 37: "44", - 38: "71", - 39: "72", - 40: "73", - 41: "79", - 42: "81", - 43: "82", + 38: "45", + 39: "71", + 40: "72", + 41: "73", + 42: "79", + 43: "81", + 44: "82", } // Decode decodes BlockchainConfig from json. @@ -6459,6 +6803,16 @@ func (s *BlockchainConfig) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"44\"") } + case "45": + if err := func() error { + s.R45.Reset() + if err := s.R45.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"45\"") + } case "71": if err := func() error { s.R71.Reset() @@ -9290,6 +9644,225 @@ func (s *BlockchainConfig44) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *BlockchainConfig45) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BlockchainConfig45) encodeFields(e *jx.Encoder) { + { + e.FieldStart("contracts") + e.ArrStart() + for _, elem := range s.Contracts { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfBlockchainConfig45 = [1]string{ + 0: "contracts", +} + +// Decode decodes BlockchainConfig45 from json. +func (s *BlockchainConfig45) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BlockchainConfig45 to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "contracts": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Contracts = make([]BlockchainConfig45ContractsItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem BlockchainConfig45ContractsItem + if err := elem.Decode(d); err != nil { + return err + } + s.Contracts = append(s.Contracts, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"contracts\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BlockchainConfig45") + } + // 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(jsonFieldsNameOfBlockchainConfig45) { + name = jsonFieldsNameOfBlockchainConfig45[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 *BlockchainConfig45) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BlockchainConfig45) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *BlockchainConfig45ContractsItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BlockchainConfig45ContractsItem) encodeFields(e *jx.Encoder) { + { + e.FieldStart("code_hash") + e.Str(s.CodeHash) + } + { + e.FieldStart("gas_usage") + e.Int64(s.GasUsage) + } +} + +var jsonFieldsNameOfBlockchainConfig45ContractsItem = [2]string{ + 0: "code_hash", + 1: "gas_usage", +} + +// Decode decodes BlockchainConfig45ContractsItem from json. +func (s *BlockchainConfig45ContractsItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BlockchainConfig45ContractsItem to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "code_hash": + requiredBitSet[0] |= 1 << 0 + 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 "gas_usage": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int64() + s.GasUsage = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"gas_usage\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode BlockchainConfig45ContractsItem") + } + // 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(jsonFieldsNameOfBlockchainConfig45ContractsItem) { + name = jsonFieldsNameOfBlockchainConfig45ContractsItem[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 *BlockchainConfig45ContractsItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BlockchainConfig45ContractsItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *BlockchainConfig5) Encode(e *jx.Encoder) { e.ObjStart() @@ -10537,6 +11110,102 @@ func (s *BlockchainConfig9) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *BlockchainLibrary) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *BlockchainLibrary) encodeFields(e *jx.Encoder) { + { + e.FieldStart("boc") + e.Str(s.Boc) + } +} + +var jsonFieldsNameOfBlockchainLibrary = [1]string{ + 0: "boc", +} + +// Decode decodes BlockchainLibrary from json. +func (s *BlockchainLibrary) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode BlockchainLibrary 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 BlockchainLibrary") + } + // 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(jsonFieldsNameOfBlockchainLibrary) { + name = jsonFieldsNameOfBlockchainLibrary[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 *BlockchainLibrary) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *BlockchainLibrary) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *BlockchainRawAccount) Encode(e *jx.Encoder) { e.ObjStart() @@ -10555,9 +11224,13 @@ func (s *BlockchainRawAccount) encodeFields(e *jx.Encoder) { e.Int64(s.Balance) } { - if s.ExtraBalance.Set { + if s.ExtraBalance != nil { e.FieldStart("extra_balance") - s.ExtraBalance.Encode(e) + e.ArrStart() + for _, elem := range s.ExtraBalance { + elem.Encode(e) + } + e.ArrEnd() } } { @@ -10657,8 +11330,15 @@ func (s *BlockchainRawAccount) Decode(d *jx.Decoder) error { } case "extra_balance": if err := func() error { - s.ExtraBalance.Reset() - if err := s.ExtraBalance.Decode(d); err != nil { + s.ExtraBalance = make([]ExtraCurrency, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ExtraCurrency + if err := elem.Decode(d); err != nil { + return err + } + s.ExtraBalance = append(s.ExtraBalance, elem) + return nil + }); err != nil { return err } return nil @@ -10811,62 +11491,6 @@ func (s *BlockchainRawAccount) UnmarshalJSON(data []byte) error { return s.Decode(d) } -// Encode implements json.Marshaler. -func (s BlockchainRawAccountExtraBalance) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields implements json.Marshaler. -func (s BlockchainRawAccountExtraBalance) encodeFields(e *jx.Encoder) { - for k, elem := range s { - e.FieldStart(k) - - e.Str(elem) - } -} - -// Decode decodes BlockchainRawAccountExtraBalance from json. -func (s *BlockchainRawAccountExtraBalance) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode BlockchainRawAccountExtraBalance to nil") - } - m := s.init() - if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - var elem string - if err := func() error { - v, err := d.Str() - elem = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrapf(err, "decode field %q", k) - } - m[string(k)] = elem - return nil - }); err != nil { - return errors.Wrap(err, "decode BlockchainRawAccountExtraBalance") - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s BlockchainRawAccountExtraBalance) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *BlockchainRawAccountExtraBalance) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - // Encode implements json.Marshaler. func (s *BlockchainRawAccountLibrariesItem) Encode(e *jx.Encoder) { e.ObjStart() @@ -11022,6 +11646,70 @@ func (s *BouncePhaseType) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes ChartPoints as json. +func (s ChartPoints) Encode(e *jx.Encoder) { + unwrapped := [][]float64(s) + + e.ArrStart() + for _, elem := range unwrapped { + e.ArrStart() + for _, elem := range elem { + e.Float64(elem) + } + e.ArrEnd() + } + e.ArrEnd() +} + +// Decode decodes ChartPoints from json. +func (s *ChartPoints) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ChartPoints to nil") + } + var unwrapped [][]float64 + if err := func() error { + unwrapped = make([][]float64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem []float64 + elem = make([]float64, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elemElem float64 + v, err := d.Float64() + elemElem = float64(v) + if err != nil { + return err + } + elem = append(elem, elemElem) + return nil + }); err != nil { + return err + } + unwrapped = append(unwrapped, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "alias") + } + *s = ChartPoints(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ChartPoints) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ChartPoints) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *ComputePhase) Encode(e *jx.Encoder) { e.ObjStart() @@ -11259,6 +11947,8 @@ func (s *ComputeSkipReason) Decode(d *jx.Decoder) error { *s = ComputeSkipReasonCskipBadState case ComputeSkipReasonCskipNoGas: *s = ComputeSkipReasonCskipNoGas + case ComputeSkipReasonCskipSuspended: + *s = ComputeSkipReasonCskipSuspended default: *s = ComputeSkipReason(v) } @@ -11732,6 +12422,50 @@ func (s *CreditPhase) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes CurrencyType as json. +func (s CurrencyType) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes CurrencyType from json. +func (s *CurrencyType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode CurrencyType to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch CurrencyType(v) { + case CurrencyTypeNative: + *s = CurrencyTypeNative + case CurrencyTypeExtraCurrency: + *s = CurrencyTypeExtraCurrency + case CurrencyTypeJetton: + *s = CurrencyTypeJetton + case CurrencyTypeFiat: + *s = CurrencyTypeFiat + default: + *s = CurrencyType(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s CurrencyType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CurrencyType) 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() @@ -11977,6 +12711,12 @@ func (s *DecodedMessageExtInMsgDecoded) encodeFields(e *jx.Encoder) { s.WalletV4.Encode(e) } } + { + if s.WalletV5.Set { + e.FieldStart("wallet_v5") + s.WalletV5.Encode(e) + } + } { if s.WalletHighloadV2.Set { e.FieldStart("wallet_highload_v2") @@ -11985,10 +12725,11 @@ func (s *DecodedMessageExtInMsgDecoded) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfDecodedMessageExtInMsgDecoded = [3]string{ +var jsonFieldsNameOfDecodedMessageExtInMsgDecoded = [4]string{ 0: "wallet_v3", 1: "wallet_v4", - 2: "wallet_highload_v2", + 2: "wallet_v5", + 3: "wallet_highload_v2", } // Decode decodes DecodedMessageExtInMsgDecoded from json. @@ -12019,6 +12760,16 @@ func (s *DecodedMessageExtInMsgDecoded) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"wallet_v4\"") } + case "wallet_v5": + if err := func() error { + s.WalletV5.Reset() + if err := s.WalletV5.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet_v5\"") + } case "wallet_highload_v2": if err := func() error { s.WalletHighloadV2.Reset() @@ -12524,6 +13275,129 @@ func (s *DecodedMessageExtInMsgDecodedWalletV4) UnmarshalJSON(data []byte) error return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *DecodedMessageExtInMsgDecodedWalletV5) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DecodedMessageExtInMsgDecodedWalletV5) encodeFields(e *jx.Encoder) { + { + e.FieldStart("valid_until") + e.Int64(s.ValidUntil) + } + { + e.FieldStart("raw_messages") + e.ArrStart() + for _, elem := range s.RawMessages { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV5 = [2]string{ + 0: "valid_until", + 1: "raw_messages", +} + +// Decode decodes DecodedMessageExtInMsgDecodedWalletV5 from json. +func (s *DecodedMessageExtInMsgDecodedWalletV5) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecodedWalletV5 to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "valid_until": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int64() + s.ValidUntil = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"valid_until\"") + } + case "raw_messages": + requiredBitSet[0] |= 1 << 1 + 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 DecodedMessageExtInMsgDecodedWalletV5") + } + // 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(jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV5) { + name = jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV5[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 *DecodedMessageExtInMsgDecodedWalletV5) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DecodedMessageExtInMsgDecodedWalletV5) 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() @@ -12924,6 +13798,132 @@ func (s *DepositStakeAction) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *DepositTokenStakeAction) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DepositTokenStakeAction) encodeFields(e *jx.Encoder) { + { + e.FieldStart("staker") + s.Staker.Encode(e) + } + { + e.FieldStart("protocol") + s.Protocol.Encode(e) + } + { + if s.StakeMeta.Set { + e.FieldStart("stake_meta") + s.StakeMeta.Encode(e) + } + } +} + +var jsonFieldsNameOfDepositTokenStakeAction = [3]string{ + 0: "staker", + 1: "protocol", + 2: "stake_meta", +} + +// Decode decodes DepositTokenStakeAction from json. +func (s *DepositTokenStakeAction) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DepositTokenStakeAction to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "staker": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Staker.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"staker\"") + } + case "protocol": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Protocol.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"protocol\"") + } + case "stake_meta": + if err := func() error { + s.StakeMeta.Reset() + if err := s.StakeMeta.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"stake_meta\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DepositTokenStakeAction") + } + // 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(jsonFieldsNameOfDepositTokenStakeAction) { + name = jsonFieldsNameOfDepositTokenStakeAction[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 *DepositTokenStakeAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DepositTokenStakeAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *DnsExpiring) Encode(e *jx.Encoder) { e.ObjStart() @@ -13955,71 +14955,107 @@ func (s *DomainRenewAction) UnmarshalJSON(data []byte) error { } // Encode implements json.Marshaler. -func (s *ElectionsDepositStakeAction) Encode(e *jx.Encoder) { +func (s *EcPreview) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ElectionsDepositStakeAction) encodeFields(e *jx.Encoder) { +func (s *EcPreview) encodeFields(e *jx.Encoder) { { - e.FieldStart("amount") - e.Int64(s.Amount) + e.FieldStart("id") + e.Int32(s.ID) } { - e.FieldStart("staker") - s.Staker.Encode(e) + e.FieldStart("symbol") + e.Str(s.Symbol) + } + { + e.FieldStart("decimals") + e.Int(s.Decimals) + } + { + e.FieldStart("image") + e.Str(s.Image) } } -var jsonFieldsNameOfElectionsDepositStakeAction = [2]string{ - 0: "amount", - 1: "staker", +var jsonFieldsNameOfEcPreview = [4]string{ + 0: "id", + 1: "symbol", + 2: "decimals", + 3: "image", } -// Decode decodes ElectionsDepositStakeAction from json. -func (s *ElectionsDepositStakeAction) Decode(d *jx.Decoder) error { +// Decode decodes EcPreview from json. +func (s *EcPreview) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ElectionsDepositStakeAction to nil") + return errors.New("invalid: unable to decode EcPreview to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "amount": + case "id": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.Amount = int64(v) + v, err := d.Int32() + s.ID = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") + return errors.Wrap(err, "decode field \"id\"") } - case "staker": + case "symbol": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Staker.Decode(d); err != nil { + v, err := d.Str() + s.Symbol = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"staker\"") + return errors.Wrap(err, "decode field \"symbol\"") + } + case "decimals": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.Decimals = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"decimals\"") + } + case "image": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.Image = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"image\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ElectionsDepositStakeAction") + return errors.Wrap(err, "decode EcPreview") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000011, + 0b00001111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -14031,8 +15067,8 @@ func (s *ElectionsDepositStakeAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfElectionsDepositStakeAction) { - name = jsonFieldsNameOfElectionsDepositStakeAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfEcPreview) { + name = jsonFieldsNameOfEcPreview[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -14053,27 +15089,27 @@ func (s *ElectionsDepositStakeAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ElectionsDepositStakeAction) MarshalJSON() ([]byte, error) { +func (s *EcPreview) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ElectionsDepositStakeAction) UnmarshalJSON(data []byte) error { +func (s *EcPreview) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ElectionsRecoverStakeAction) Encode(e *jx.Encoder) { +func (s *ElectionsDepositStakeAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ElectionsRecoverStakeAction) encodeFields(e *jx.Encoder) { +func (s *ElectionsDepositStakeAction) encodeFields(e *jx.Encoder) { { e.FieldStart("amount") e.Int64(s.Amount) @@ -14084,15 +15120,15 @@ func (s *ElectionsRecoverStakeAction) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfElectionsRecoverStakeAction = [2]string{ +var jsonFieldsNameOfElectionsDepositStakeAction = [2]string{ 0: "amount", 1: "staker", } -// Decode decodes ElectionsRecoverStakeAction from json. -func (s *ElectionsRecoverStakeAction) Decode(d *jx.Decoder) error { +// Decode decodes ElectionsDepositStakeAction from json. +func (s *ElectionsDepositStakeAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ElectionsRecoverStakeAction to nil") + return errors.New("invalid: unable to decode ElectionsDepositStakeAction to nil") } var requiredBitSet [1]uint8 @@ -14125,7 +15161,7 @@ func (s *ElectionsRecoverStakeAction) Decode(d *jx.Decoder) error { } return nil }); err != nil { - return errors.Wrap(err, "decode ElectionsRecoverStakeAction") + return errors.Wrap(err, "decode ElectionsDepositStakeAction") } // Validate required fields. var failures []validate.FieldError @@ -14142,8 +15178,8 @@ func (s *ElectionsRecoverStakeAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfElectionsRecoverStakeAction) { - name = jsonFieldsNameOfElectionsRecoverStakeAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfElectionsDepositStakeAction) { + name = jsonFieldsNameOfElectionsDepositStakeAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -14164,69 +15200,84 @@ func (s *ElectionsRecoverStakeAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ElectionsRecoverStakeAction) MarshalJSON() ([]byte, error) { +func (s *ElectionsDepositStakeAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ElectionsRecoverStakeAction) UnmarshalJSON(data []byte) error { +func (s *ElectionsDepositStakeAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *EmulateMessageToAccountEventReq) Encode(e *jx.Encoder) { +func (s *ElectionsRecoverStakeAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *EmulateMessageToAccountEventReq) encodeFields(e *jx.Encoder) { +func (s *ElectionsRecoverStakeAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("boc") - e.Str(s.Boc) + e.FieldStart("amount") + e.Int64(s.Amount) + } + { + e.FieldStart("staker") + s.Staker.Encode(e) } } -var jsonFieldsNameOfEmulateMessageToAccountEventReq = [1]string{ - 0: "boc", +var jsonFieldsNameOfElectionsRecoverStakeAction = [2]string{ + 0: "amount", + 1: "staker", } -// Decode decodes EmulateMessageToAccountEventReq from json. -func (s *EmulateMessageToAccountEventReq) Decode(d *jx.Decoder) error { +// Decode decodes ElectionsRecoverStakeAction from json. +func (s *ElectionsRecoverStakeAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode EmulateMessageToAccountEventReq to nil") + return errors.New("invalid: unable to decode ElectionsRecoverStakeAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "boc": + case "amount": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Boc = string(v) + v, err := d.Int64() + s.Amount = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"boc\"") + return errors.Wrap(err, "decode field \"amount\"") + } + case "staker": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Staker.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"staker\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode EmulateMessageToAccountEventReq") + return errors.Wrap(err, "decode ElectionsRecoverStakeAction") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -14238,8 +15289,8 @@ func (s *EmulateMessageToAccountEventReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfEmulateMessageToAccountEventReq) { - name = jsonFieldsNameOfEmulateMessageToAccountEventReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfElectionsRecoverStakeAction) { + name = jsonFieldsNameOfElectionsRecoverStakeAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -14260,41 +15311,137 @@ func (s *EmulateMessageToAccountEventReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *EmulateMessageToAccountEventReq) MarshalJSON() ([]byte, error) { +func (s *ElectionsRecoverStakeAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *EmulateMessageToAccountEventReq) UnmarshalJSON(data []byte) error { +func (s *ElectionsRecoverStakeAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *EmulateMessageToEventReq) Encode(e *jx.Encoder) { +func (s *EmulateMessageToAccountEventReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *EmulateMessageToEventReq) encodeFields(e *jx.Encoder) { +func (s *EmulateMessageToAccountEventReq) encodeFields(e *jx.Encoder) { { e.FieldStart("boc") e.Str(s.Boc) } } -var jsonFieldsNameOfEmulateMessageToEventReq = [1]string{ +var jsonFieldsNameOfEmulateMessageToAccountEventReq = [1]string{ 0: "boc", } -// Decode decodes EmulateMessageToEventReq from json. -func (s *EmulateMessageToEventReq) Decode(d *jx.Decoder) error { +// Decode decodes EmulateMessageToAccountEventReq from json. +func (s *EmulateMessageToAccountEventReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode EmulateMessageToEventReq to nil") + return errors.New("invalid: unable to decode EmulateMessageToAccountEventReq 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 EmulateMessageToAccountEventReq") + } + // 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(jsonFieldsNameOfEmulateMessageToAccountEventReq) { + name = jsonFieldsNameOfEmulateMessageToAccountEventReq[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 *EmulateMessageToAccountEventReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *EmulateMessageToAccountEventReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *EmulateMessageToEventReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *EmulateMessageToEventReq) encodeFields(e *jx.Encoder) { + { + e.FieldStart("boc") + e.Str(s.Boc) + } +} + +var jsonFieldsNameOfEmulateMessageToEventReq = [1]string{ + 0: "boc", +} + +// Decode decodes EmulateMessageToEventReq from json. +func (s *EmulateMessageToEventReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode EmulateMessageToEventReq to nil") } var requiredBitSet [1]uint8 @@ -14827,10 +15974,17 @@ func (s *Error) encodeFields(e *jx.Encoder) { e.FieldStart("error") e.Str(s.Error) } + { + if s.ErrorCode.Set { + e.FieldStart("error_code") + s.ErrorCode.Encode(e) + } + } } -var jsonFieldsNameOfError = [1]string{ +var jsonFieldsNameOfError = [2]string{ 0: "error", + 1: "error_code", } // Decode decodes Error from json. @@ -14854,6 +16008,16 @@ func (s *Error) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"error\"") } + case "error_code": + if err := func() error { + s.ErrorCode.Reset() + if err := s.ErrorCode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"error_code\"") + } default: return d.Skip() } @@ -14955,9 +16119,13 @@ func (s *Event) encodeFields(e *jx.Encoder) { e.FieldStart("in_progress") e.Bool(s.InProgress) } + { + e.FieldStart("progress") + e.Float32(s.Progress) + } } -var jsonFieldsNameOfEvent = [7]string{ +var jsonFieldsNameOfEvent = [8]string{ 0: "event_id", 1: "timestamp", 2: "actions", @@ -14965,6 +16133,7 @@ var jsonFieldsNameOfEvent = [7]string{ 4: "is_scam", 5: "lt", 6: "in_progress", + 7: "progress", } // Decode decodes Event from json. @@ -15072,6 +16241,18 @@ func (s *Event) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"in_progress\"") } + case "progress": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + v, err := d.Float32() + s.Progress = float32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"progress\"") + } default: return d.Skip() } @@ -15082,7 +16263,7 @@ func (s *Event) Decode(d *jx.Decoder) error { // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b01111111, + 0b11111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -15129,61 +16310,222 @@ func (s *Event) UnmarshalJSON(data []byte) error { } // Encode implements json.Marshaler. -func (s *FoundAccounts) Encode(e *jx.Encoder) { +func (s *ExecGetMethodArg) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *FoundAccounts) encodeFields(e *jx.Encoder) { +func (s *ExecGetMethodArg) encodeFields(e *jx.Encoder) { { - e.FieldStart("addresses") + e.FieldStart("type") + s.Type.Encode(e) + } + { + e.FieldStart("value") + e.Str(s.Value) + } +} + +var jsonFieldsNameOfExecGetMethodArg = [2]string{ + 0: "type", + 1: "value", +} + +// Decode decodes ExecGetMethodArg from json. +func (s *ExecGetMethodArg) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ExecGetMethodArg to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "type": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Type.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"type\"") + } + 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 ExecGetMethodArg") + } + // 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(jsonFieldsNameOfExecGetMethodArg) { + name = jsonFieldsNameOfExecGetMethodArg[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 *ExecGetMethodArg) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ExecGetMethodArg) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ExecGetMethodArgType as json. +func (s ExecGetMethodArgType) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes ExecGetMethodArgType from json. +func (s *ExecGetMethodArgType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ExecGetMethodArgType to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch ExecGetMethodArgType(v) { + case ExecGetMethodArgTypeNan: + *s = ExecGetMethodArgTypeNan + case ExecGetMethodArgTypeNull: + *s = ExecGetMethodArgTypeNull + case ExecGetMethodArgTypeTinyint: + *s = ExecGetMethodArgTypeTinyint + case ExecGetMethodArgTypeInt257: + *s = ExecGetMethodArgTypeInt257 + case ExecGetMethodArgTypeSlice: + *s = ExecGetMethodArgTypeSlice + case ExecGetMethodArgTypeCellBocBase64: + *s = ExecGetMethodArgTypeCellBocBase64 + case ExecGetMethodArgTypeSliceBocHex: + *s = ExecGetMethodArgTypeSliceBocHex + default: + *s = ExecGetMethodArgType(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s ExecGetMethodArgType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *ExecGetMethodArgType) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ExecGetMethodWithBodyForBlockchainAccountReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ExecGetMethodWithBodyForBlockchainAccountReq) encodeFields(e *jx.Encoder) { + { + e.FieldStart("args") e.ArrStart() - for _, elem := range s.Addresses { + for _, elem := range s.Args { elem.Encode(e) } e.ArrEnd() } } -var jsonFieldsNameOfFoundAccounts = [1]string{ - 0: "addresses", +var jsonFieldsNameOfExecGetMethodWithBodyForBlockchainAccountReq = [1]string{ + 0: "args", } -// Decode decodes FoundAccounts from json. -func (s *FoundAccounts) Decode(d *jx.Decoder) error { +// Decode decodes ExecGetMethodWithBodyForBlockchainAccountReq from json. +func (s *ExecGetMethodWithBodyForBlockchainAccountReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode FoundAccounts to nil") + return errors.New("invalid: unable to decode ExecGetMethodWithBodyForBlockchainAccountReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "addresses": + case "args": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Addresses = make([]FoundAccountsAddressesItem, 0) + s.Args = make([]ExecGetMethodArg, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem FoundAccountsAddressesItem + var elem ExecGetMethodArg if err := elem.Decode(d); err != nil { return err } - s.Addresses = append(s.Addresses, elem) + s.Args = append(s.Args, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"addresses\"") + return errors.Wrap(err, "decode field \"args\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode FoundAccounts") + return errors.Wrap(err, "decode ExecGetMethodWithBodyForBlockchainAccountReq") } // Validate required fields. var failures []validate.FieldError @@ -15200,8 +16542,8 @@ func (s *FoundAccounts) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfFoundAccounts) { - name = jsonFieldsNameOfFoundAccounts[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfExecGetMethodWithBodyForBlockchainAccountReq) { + name = jsonFieldsNameOfExecGetMethodWithBodyForBlockchainAccountReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15222,86 +16564,67 @@ func (s *FoundAccounts) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *FoundAccounts) MarshalJSON() ([]byte, error) { +func (s *ExecGetMethodWithBodyForBlockchainAccountReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *FoundAccounts) UnmarshalJSON(data []byte) error { +func (s *ExecGetMethodWithBodyForBlockchainAccountReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *FoundAccountsAddressesItem) Encode(e *jx.Encoder) { +func (s *ExtraCurrency) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *FoundAccountsAddressesItem) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } +func (s *ExtraCurrency) encodeFields(e *jx.Encoder) { { - e.FieldStart("name") - e.Str(s.Name) + e.FieldStart("amount") + e.Str(s.Amount) } { e.FieldStart("preview") - e.Str(s.Preview) + s.Preview.Encode(e) } } -var jsonFieldsNameOfFoundAccountsAddressesItem = [3]string{ - 0: "address", - 1: "name", - 2: "preview", +var jsonFieldsNameOfExtraCurrency = [2]string{ + 0: "amount", + 1: "preview", } -// Decode decodes FoundAccountsAddressesItem from json. -func (s *FoundAccountsAddressesItem) Decode(d *jx.Decoder) error { +// Decode decodes ExtraCurrency from json. +func (s *ExtraCurrency) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode FoundAccountsAddressesItem to nil") + return errors.New("invalid: unable to decode ExtraCurrency to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "amount": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.Address = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") - } - case "name": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Str() - s.Name = string(v) + s.Amount = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"name\"") + return errors.Wrap(err, "decode field \"amount\"") } case "preview": - requiredBitSet[0] |= 1 << 2 + requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.Preview = string(v) - if err != nil { + if err := s.Preview.Decode(d); err != nil { return err } return nil @@ -15313,12 +16636,12 @@ func (s *FoundAccountsAddressesItem) Decode(d *jx.Decoder) error { } return nil }); err != nil { - return errors.Wrap(err, "decode FoundAccountsAddressesItem") + return errors.Wrap(err, "decode ExtraCurrency") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -15330,8 +16653,8 @@ func (s *FoundAccountsAddressesItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfFoundAccountsAddressesItem) { - name = jsonFieldsNameOfFoundAccountsAddressesItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfExtraCurrency) { + name = jsonFieldsNameOfExtraCurrency[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15352,206 +16675,148 @@ func (s *FoundAccountsAddressesItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *FoundAccountsAddressesItem) MarshalJSON() ([]byte, error) { +func (s *ExtraCurrency) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *FoundAccountsAddressesItem) UnmarshalJSON(data []byte) error { +func (s *ExtraCurrency) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GasLimitPrices) Encode(e *jx.Encoder) { +func (s *ExtraCurrencyTransferAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GasLimitPrices) encodeFields(e *jx.Encoder) { - { - if s.SpecialGasLimit.Set { - e.FieldStart("special_gas_limit") - s.SpecialGasLimit.Encode(e) - } - } - { - if s.FlatGasLimit.Set { - e.FieldStart("flat_gas_limit") - s.FlatGasLimit.Encode(e) - } - } - { - if s.FlatGasPrice.Set { - e.FieldStart("flat_gas_price") - s.FlatGasPrice.Encode(e) - } - } +func (s *ExtraCurrencyTransferAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("gas_price") - e.Int64(s.GasPrice) + e.FieldStart("sender") + s.Sender.Encode(e) } { - e.FieldStart("gas_limit") - e.Int64(s.GasLimit) + e.FieldStart("recipient") + s.Recipient.Encode(e) } { - e.FieldStart("gas_credit") - e.Int64(s.GasCredit) + e.FieldStart("amount") + e.Str(s.Amount) } { - e.FieldStart("block_gas_limit") - e.Int64(s.BlockGasLimit) + if s.Comment.Set { + e.FieldStart("comment") + s.Comment.Encode(e) + } } { - e.FieldStart("freeze_due_limit") - e.Int64(s.FreezeDueLimit) + if s.EncryptedComment.Set { + e.FieldStart("encrypted_comment") + s.EncryptedComment.Encode(e) + } } { - e.FieldStart("delete_due_limit") - e.Int64(s.DeleteDueLimit) + e.FieldStart("currency") + s.Currency.Encode(e) } } -var jsonFieldsNameOfGasLimitPrices = [9]string{ - 0: "special_gas_limit", - 1: "flat_gas_limit", - 2: "flat_gas_price", - 3: "gas_price", - 4: "gas_limit", - 5: "gas_credit", - 6: "block_gas_limit", - 7: "freeze_due_limit", - 8: "delete_due_limit", +var jsonFieldsNameOfExtraCurrencyTransferAction = [6]string{ + 0: "sender", + 1: "recipient", + 2: "amount", + 3: "comment", + 4: "encrypted_comment", + 5: "currency", } -// Decode decodes GasLimitPrices from json. -func (s *GasLimitPrices) Decode(d *jx.Decoder) error { +// Decode decodes ExtraCurrencyTransferAction from json. +func (s *ExtraCurrencyTransferAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GasLimitPrices to nil") + return errors.New("invalid: unable to decode ExtraCurrencyTransferAction to nil") } - var requiredBitSet [2]uint8 + var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "special_gas_limit": - if err := func() error { - s.SpecialGasLimit.Reset() - if err := s.SpecialGasLimit.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"special_gas_limit\"") - } - case "flat_gas_limit": - if err := func() error { - s.FlatGasLimit.Reset() - if err := s.FlatGasLimit.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"flat_gas_limit\"") - } - case "flat_gas_price": - if err := func() error { - s.FlatGasPrice.Reset() - if err := s.FlatGasPrice.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"flat_gas_price\"") - } - case "gas_price": - requiredBitSet[0] |= 1 << 3 + case "sender": + requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.GasPrice = int64(v) - if err != nil { + if err := s.Sender.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"gas_price\"") + return errors.Wrap(err, "decode field \"sender\"") } - case "gas_limit": - requiredBitSet[0] |= 1 << 4 + case "recipient": + requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int64() - s.GasLimit = int64(v) - if err != nil { + if err := s.Recipient.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"gas_limit\"") + return errors.Wrap(err, "decode field \"recipient\"") } - case "gas_credit": - requiredBitSet[0] |= 1 << 5 + case "amount": + requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Int64() - s.GasCredit = int64(v) + v, err := d.Str() + s.Amount = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"gas_credit\"") + return errors.Wrap(err, "decode field \"amount\"") } - case "block_gas_limit": - requiredBitSet[0] |= 1 << 6 + case "comment": if err := func() error { - v, err := d.Int64() - s.BlockGasLimit = int64(v) - if err != nil { + s.Comment.Reset() + if err := s.Comment.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"block_gas_limit\"") + return errors.Wrap(err, "decode field \"comment\"") } - case "freeze_due_limit": - requiredBitSet[0] |= 1 << 7 + case "encrypted_comment": if err := func() error { - v, err := d.Int64() - s.FreezeDueLimit = int64(v) - if err != nil { + s.EncryptedComment.Reset() + if err := s.EncryptedComment.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"freeze_due_limit\"") + return errors.Wrap(err, "decode field \"encrypted_comment\"") } - case "delete_due_limit": - requiredBitSet[1] |= 1 << 0 + case "currency": + requiredBitSet[0] |= 1 << 5 if err := func() error { - v, err := d.Int64() - s.DeleteDueLimit = int64(v) - if err != nil { + if err := s.Currency.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"delete_due_limit\"") + return errors.Wrap(err, "decode field \"currency\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GasLimitPrices") + return errors.Wrap(err, "decode ExtraCurrencyTransferAction") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [2]uint8{ - 0b11111000, - 0b00000001, + for i, mask := range [1]uint8{ + 0b00100111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -15563,8 +16828,8 @@ func (s *GasLimitPrices) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGasLimitPrices) { - name = jsonFieldsNameOfGasLimitPrices[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfExtraCurrencyTransferAction) { + name = jsonFieldsNameOfExtraCurrencyTransferAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15585,96 +16850,79 @@ func (s *GasLimitPrices) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GasLimitPrices) MarshalJSON() ([]byte, error) { +func (s *ExtraCurrencyTransferAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GasLimitPrices) UnmarshalJSON(data []byte) error { +func (s *ExtraCurrencyTransferAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GaslessConfig) Encode(e *jx.Encoder) { +func (s *FoundAccounts) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GaslessConfig) encodeFields(e *jx.Encoder) { - { - e.FieldStart("relay_address") - e.Str(s.RelayAddress) - } +func (s *FoundAccounts) encodeFields(e *jx.Encoder) { { - e.FieldStart("gas_jettons") + e.FieldStart("addresses") e.ArrStart() - for _, elem := range s.GasJettons { + for _, elem := range s.Addresses { elem.Encode(e) } e.ArrEnd() } } -var jsonFieldsNameOfGaslessConfig = [2]string{ - 0: "relay_address", - 1: "gas_jettons", +var jsonFieldsNameOfFoundAccounts = [1]string{ + 0: "addresses", } -// Decode decodes GaslessConfig from json. -func (s *GaslessConfig) Decode(d *jx.Decoder) error { +// Decode decodes FoundAccounts from json. +func (s *FoundAccounts) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GaslessConfig to nil") + return errors.New("invalid: unable to decode FoundAccounts to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "relay_address": + case "addresses": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.RelayAddress = string(v) - if err != nil { + s.Addresses = make([]FoundAccountsAddressesItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem FoundAccountsAddressesItem + if err := elem.Decode(d); err != nil { + return err + } + s.Addresses = append(s.Addresses, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"relay_address\"") - } - case "gas_jettons": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - s.GasJettons = make([]GaslessConfigGasJettonsItem, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem GaslessConfigGasJettonsItem - if err := elem.Decode(d); err != nil { - return err - } - s.GasJettons = append(s.GasJettons, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"gas_jettons\"") + return errors.Wrap(err, "decode field \"addresses\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GaslessConfig") + return errors.Wrap(err, "decode FoundAccounts") } // 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. @@ -15686,8 +16934,8 @@ func (s *GaslessConfig) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGaslessConfig) { - name = jsonFieldsNameOfGaslessConfig[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfFoundAccounts) { + name = jsonFieldsNameOfFoundAccounts[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15708,69 +16956,118 @@ func (s *GaslessConfig) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GaslessConfig) MarshalJSON() ([]byte, error) { +func (s *FoundAccounts) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GaslessConfig) UnmarshalJSON(data []byte) error { +func (s *FoundAccounts) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GaslessConfigGasJettonsItem) Encode(e *jx.Encoder) { +func (s *FoundAccountsAddressesItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GaslessConfigGasJettonsItem) encodeFields(e *jx.Encoder) { +func (s *FoundAccountsAddressesItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("master_id") - e.Str(s.MasterID) + e.FieldStart("address") + e.Str(s.Address) + } + { + e.FieldStart("name") + e.Str(s.Name) + } + { + e.FieldStart("preview") + e.Str(s.Preview) + } + { + e.FieldStart("trust") + s.Trust.Encode(e) } } -var jsonFieldsNameOfGaslessConfigGasJettonsItem = [1]string{ - 0: "master_id", +var jsonFieldsNameOfFoundAccountsAddressesItem = [4]string{ + 0: "address", + 1: "name", + 2: "preview", + 3: "trust", } -// Decode decodes GaslessConfigGasJettonsItem from json. -func (s *GaslessConfigGasJettonsItem) Decode(d *jx.Decoder) error { +// Decode decodes FoundAccountsAddressesItem from json. +func (s *FoundAccountsAddressesItem) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GaslessConfigGasJettonsItem to nil") + return errors.New("invalid: unable to decode FoundAccountsAddressesItem to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "master_id": + case "address": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.MasterID = string(v) + s.Address = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"master_id\"") + return errors.Wrap(err, "decode field \"address\"") + } + case "name": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Name = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "preview": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Preview = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"preview\"") + } + case "trust": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + if err := s.Trust.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"trust\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GaslessConfigGasJettonsItem") + return errors.Wrap(err, "decode FoundAccountsAddressesItem") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00001111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -15782,8 +17079,8 @@ func (s *GaslessConfigGasJettonsItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGaslessConfigGasJettonsItem) { - name = jsonFieldsNameOfGaslessConfigGasJettonsItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfFoundAccountsAddressesItem) { + name = jsonFieldsNameOfFoundAccountsAddressesItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15804,113 +17101,206 @@ func (s *GaslessConfigGasJettonsItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GaslessConfigGasJettonsItem) MarshalJSON() ([]byte, error) { +func (s *FoundAccountsAddressesItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GaslessConfigGasJettonsItem) UnmarshalJSON(data []byte) error { +func (s *FoundAccountsAddressesItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GaslessEstimateReq) Encode(e *jx.Encoder) { +func (s *GasLimitPrices) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GaslessEstimateReq) encodeFields(e *jx.Encoder) { +func (s *GasLimitPrices) encodeFields(e *jx.Encoder) { { - e.FieldStart("wallet_address") - e.Str(s.WalletAddress) + if s.SpecialGasLimit.Set { + e.FieldStart("special_gas_limit") + s.SpecialGasLimit.Encode(e) + } } { - e.FieldStart("wallet_public_key") - e.Str(s.WalletPublicKey) + if s.FlatGasLimit.Set { + e.FieldStart("flat_gas_limit") + s.FlatGasLimit.Encode(e) + } } { - e.FieldStart("messages") - e.ArrStart() - for _, elem := range s.Messages { - elem.Encode(e) + if s.FlatGasPrice.Set { + e.FieldStart("flat_gas_price") + s.FlatGasPrice.Encode(e) } - e.ArrEnd() + } + { + e.FieldStart("gas_price") + e.Int64(s.GasPrice) + } + { + e.FieldStart("gas_limit") + e.Int64(s.GasLimit) + } + { + e.FieldStart("gas_credit") + e.Int64(s.GasCredit) + } + { + e.FieldStart("block_gas_limit") + e.Int64(s.BlockGasLimit) + } + { + e.FieldStart("freeze_due_limit") + e.Int64(s.FreezeDueLimit) + } + { + e.FieldStart("delete_due_limit") + e.Int64(s.DeleteDueLimit) } } -var jsonFieldsNameOfGaslessEstimateReq = [3]string{ - 0: "wallet_address", - 1: "wallet_public_key", - 2: "messages", +var jsonFieldsNameOfGasLimitPrices = [9]string{ + 0: "special_gas_limit", + 1: "flat_gas_limit", + 2: "flat_gas_price", + 3: "gas_price", + 4: "gas_limit", + 5: "gas_credit", + 6: "block_gas_limit", + 7: "freeze_due_limit", + 8: "delete_due_limit", } -// Decode decodes GaslessEstimateReq from json. -func (s *GaslessEstimateReq) Decode(d *jx.Decoder) error { +// Decode decodes GasLimitPrices from json. +func (s *GasLimitPrices) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GaslessEstimateReq to nil") + return errors.New("invalid: unable to decode GasLimitPrices 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 "wallet_address": - requiredBitSet[0] |= 1 << 0 + case "special_gas_limit": if err := func() error { - v, err := d.Str() - s.WalletAddress = string(v) + s.SpecialGasLimit.Reset() + if err := s.SpecialGasLimit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"special_gas_limit\"") + } + case "flat_gas_limit": + if err := func() error { + s.FlatGasLimit.Reset() + if err := s.FlatGasLimit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"flat_gas_limit\"") + } + case "flat_gas_price": + if err := func() error { + s.FlatGasPrice.Reset() + if err := s.FlatGasPrice.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"flat_gas_price\"") + } + case "gas_price": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Int64() + s.GasPrice = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"wallet_address\"") + return errors.Wrap(err, "decode field \"gas_price\"") } - case "wallet_public_key": - requiredBitSet[0] |= 1 << 1 + case "gas_limit": + requiredBitSet[0] |= 1 << 4 if err := func() error { - v, err := d.Str() - s.WalletPublicKey = string(v) + v, err := d.Int64() + s.GasLimit = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"wallet_public_key\"") + return errors.Wrap(err, "decode field \"gas_limit\"") } - case "messages": - requiredBitSet[0] |= 1 << 2 + case "gas_credit": + requiredBitSet[0] |= 1 << 5 if err := func() error { - s.Messages = make([]GaslessEstimateReqMessagesItem, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem GaslessEstimateReqMessagesItem - if err := elem.Decode(d); err != nil { - return err - } - s.Messages = append(s.Messages, elem) - return nil - }); err != nil { + v, err := d.Int64() + s.GasCredit = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"messages\"") + return errors.Wrap(err, "decode field \"gas_credit\"") + } + case "block_gas_limit": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + v, err := d.Int64() + s.BlockGasLimit = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"block_gas_limit\"") + } + case "freeze_due_limit": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + v, err := d.Int64() + s.FreezeDueLimit = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"freeze_due_limit\"") + } + case "delete_due_limit": + requiredBitSet[1] |= 1 << 0 + if err := func() error { + v, err := d.Int64() + s.DeleteDueLimit = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"delete_due_limit\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GaslessEstimateReq") + return errors.Wrap(err, "decode GasLimitPrices") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ - 0b00000111, + for i, mask := range [2]uint8{ + 0b11111000, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -15922,8 +17312,8 @@ func (s *GaslessEstimateReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGaslessEstimateReq) { - name = jsonFieldsNameOfGaslessEstimateReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGasLimitPrices) { + name = jsonFieldsNameOfGasLimitPrices[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15944,69 +17334,99 @@ func (s *GaslessEstimateReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GaslessEstimateReq) MarshalJSON() ([]byte, error) { +func (s *GasLimitPrices) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GaslessEstimateReq) UnmarshalJSON(data []byte) error { +func (s *GasLimitPrices) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GaslessEstimateReqMessagesItem) Encode(e *jx.Encoder) { +func (s *GasRelayAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GaslessEstimateReqMessagesItem) encodeFields(e *jx.Encoder) { +func (s *GasRelayAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("boc") - e.Str(s.Boc) + e.FieldStart("amount") + e.Int64(s.Amount) + } + { + e.FieldStart("relayer") + s.Relayer.Encode(e) + } + { + e.FieldStart("target") + s.Target.Encode(e) } } -var jsonFieldsNameOfGaslessEstimateReqMessagesItem = [1]string{ - 0: "boc", +var jsonFieldsNameOfGasRelayAction = [3]string{ + 0: "amount", + 1: "relayer", + 2: "target", } -// Decode decodes GaslessEstimateReqMessagesItem from json. -func (s *GaslessEstimateReqMessagesItem) Decode(d *jx.Decoder) error { +// Decode decodes GasRelayAction from json. +func (s *GasRelayAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GaslessEstimateReqMessagesItem to nil") + return errors.New("invalid: unable to decode GasRelayAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "boc": + case "amount": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Boc = string(v) + v, err := d.Int64() + s.Amount = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"boc\"") + return errors.Wrap(err, "decode field \"amount\"") + } + case "relayer": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Relayer.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"relayer\"") + } + case "target": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.Target.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"target\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GaslessEstimateReqMessagesItem") + return errors.Wrap(err, "decode GasRelayAction") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -16018,8 +17438,8 @@ func (s *GaslessEstimateReqMessagesItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGaslessEstimateReqMessagesItem) { - name = jsonFieldsNameOfGaslessEstimateReqMessagesItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGasRelayAction) { + name = jsonFieldsNameOfGasRelayAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16040,81 +17460,91 @@ func (s *GaslessEstimateReqMessagesItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GaslessEstimateReqMessagesItem) MarshalJSON() ([]byte, error) { +func (s *GasRelayAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GaslessEstimateReqMessagesItem) UnmarshalJSON(data []byte) error { +func (s *GasRelayAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GaslessSendReq) Encode(e *jx.Encoder) { +func (s *GaslessConfig) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GaslessSendReq) encodeFields(e *jx.Encoder) { +func (s *GaslessConfig) encodeFields(e *jx.Encoder) { { - e.FieldStart("wallet_public_key") - e.Str(s.WalletPublicKey) + e.FieldStart("relay_address") + e.Str(s.RelayAddress) } { - e.FieldStart("boc") - e.Str(s.Boc) + e.FieldStart("gas_jettons") + e.ArrStart() + for _, elem := range s.GasJettons { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfGaslessSendReq = [2]string{ - 0: "wallet_public_key", - 1: "boc", +var jsonFieldsNameOfGaslessConfig = [2]string{ + 0: "relay_address", + 1: "gas_jettons", } -// Decode decodes GaslessSendReq from json. -func (s *GaslessSendReq) Decode(d *jx.Decoder) error { +// Decode decodes GaslessConfig from json. +func (s *GaslessConfig) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GaslessSendReq to nil") + return errors.New("invalid: unable to decode GaslessConfig to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "wallet_public_key": + case "relay_address": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.WalletPublicKey = string(v) + s.RelayAddress = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"wallet_public_key\"") + return errors.Wrap(err, "decode field \"relay_address\"") } - case "boc": + case "gas_jettons": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.Boc = string(v) - if err != nil { + s.GasJettons = make([]GaslessConfigGasJettonsItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem GaslessConfigGasJettonsItem + if err := elem.Decode(d); err != nil { + return err + } + s.GasJettons = append(s.GasJettons, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"boc\"") + return errors.Wrap(err, "decode field \"gas_jettons\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GaslessSendReq") + return errors.Wrap(err, "decode GaslessConfig") } // Validate required fields. var failures []validate.FieldError @@ -16131,8 +17561,8 @@ func (s *GaslessSendReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGaslessSendReq) { - name = jsonFieldsNameOfGaslessSendReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGaslessConfig) { + name = jsonFieldsNameOfGaslessConfig[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16153,64 +17583,64 @@ func (s *GaslessSendReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GaslessSendReq) MarshalJSON() ([]byte, error) { +func (s *GaslessConfig) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GaslessSendReq) UnmarshalJSON(data []byte) error { +func (s *GaslessConfig) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetAccountDiffOK) Encode(e *jx.Encoder) { +func (s *GaslessConfigGasJettonsItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetAccountDiffOK) encodeFields(e *jx.Encoder) { +func (s *GaslessConfigGasJettonsItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("balance_change") - e.Int64(s.BalanceChange) + e.FieldStart("master_id") + e.Str(s.MasterID) } } -var jsonFieldsNameOfGetAccountDiffOK = [1]string{ - 0: "balance_change", +var jsonFieldsNameOfGaslessConfigGasJettonsItem = [1]string{ + 0: "master_id", } -// Decode decodes GetAccountDiffOK from json. -func (s *GetAccountDiffOK) Decode(d *jx.Decoder) error { +// Decode decodes GaslessConfigGasJettonsItem from json. +func (s *GaslessConfigGasJettonsItem) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetAccountDiffOK to nil") + return errors.New("invalid: unable to decode GaslessConfigGasJettonsItem to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "balance_change": + case "master_id": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.BalanceChange = int64(v) + v, err := d.Str() + s.MasterID = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"balance_change\"") + return errors.Wrap(err, "decode field \"master_id\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetAccountDiffOK") + return errors.Wrap(err, "decode GaslessConfigGasJettonsItem") } // Validate required fields. var failures []validate.FieldError @@ -16227,8 +17657,8 @@ func (s *GetAccountDiffOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetAccountDiffOK) { - name = jsonFieldsNameOfGetAccountDiffOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGaslessConfigGasJettonsItem) { + name = jsonFieldsNameOfGaslessConfigGasJettonsItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16249,82 +17679,161 @@ func (s *GetAccountDiffOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetAccountDiffOK) MarshalJSON() ([]byte, error) { +func (s *GaslessConfigGasJettonsItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetAccountDiffOK) UnmarshalJSON(data []byte) error { +func (s *GaslessConfigGasJettonsItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetAccountInfoByStateInitReq) Encode(e *jx.Encoder) { +func (s *GaslessEstimateReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetAccountInfoByStateInitReq) encodeFields(e *jx.Encoder) { +func (s *GaslessEstimateReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("state_init") - e.Str(s.StateInit) + if s.ThrowErrorIfNotEnoughJettons.Set { + e.FieldStart("throw_error_if_not_enough_jettons") + s.ThrowErrorIfNotEnoughJettons.Encode(e) + } + } + { + if s.ReturnEmulation.Set { + e.FieldStart("return_emulation") + s.ReturnEmulation.Encode(e) + } + } + { + e.FieldStart("wallet_address") + e.Str(s.WalletAddress) + } + { + e.FieldStart("wallet_public_key") + e.Str(s.WalletPublicKey) + } + { + e.FieldStart("messages") + e.ArrStart() + for _, elem := range s.Messages { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfGetAccountInfoByStateInitReq = [1]string{ - 0: "state_init", +var jsonFieldsNameOfGaslessEstimateReq = [5]string{ + 0: "throw_error_if_not_enough_jettons", + 1: "return_emulation", + 2: "wallet_address", + 3: "wallet_public_key", + 4: "messages", } -// Decode decodes GetAccountInfoByStateInitReq from json. -func (s *GetAccountInfoByStateInitReq) Decode(d *jx.Decoder) error { +// Decode decodes GaslessEstimateReq from json. +func (s *GaslessEstimateReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetAccountInfoByStateInitReq to nil") + return errors.New("invalid: unable to decode GaslessEstimateReq to nil") } var requiredBitSet [1]uint8 + s.setDefaults() if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "state_init": - requiredBitSet[0] |= 1 << 0 + case "throw_error_if_not_enough_jettons": + if err := func() error { + s.ThrowErrorIfNotEnoughJettons.Reset() + if err := s.ThrowErrorIfNotEnoughJettons.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"throw_error_if_not_enough_jettons\"") + } + case "return_emulation": + if err := func() error { + s.ReturnEmulation.Reset() + if err := s.ReturnEmulation.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"return_emulation\"") + } + case "wallet_address": + requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.StateInit = string(v) + s.WalletAddress = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"state_init\"") + return errors.Wrap(err, "decode field \"wallet_address\"") } - default: - return d.Skip() - } - return nil - }); err != nil { - return errors.Wrap(err, "decode GetAccountInfoByStateInitReq") - } - // 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. + case "wallet_public_key": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.WalletPublicKey = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet_public_key\"") + } + case "messages": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + s.Messages = make([]GaslessEstimateReqMessagesItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem GaslessEstimateReqMessagesItem + if err := elem.Decode(d); err != nil { + return err + } + s.Messages = append(s.Messages, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"messages\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode GaslessEstimateReq") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00011100, + } { + 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(jsonFieldsNameOfGetAccountInfoByStateInitReq) { - name = jsonFieldsNameOfGetAccountInfoByStateInitReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGaslessEstimateReq) { + name = jsonFieldsNameOfGaslessEstimateReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16345,64 +17854,64 @@ func (s *GetAccountInfoByStateInitReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetAccountInfoByStateInitReq) MarshalJSON() ([]byte, error) { +func (s *GaslessEstimateReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetAccountInfoByStateInitReq) UnmarshalJSON(data []byte) error { +func (s *GaslessEstimateReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetAccountPublicKeyOK) Encode(e *jx.Encoder) { +func (s *GaslessEstimateReqMessagesItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetAccountPublicKeyOK) encodeFields(e *jx.Encoder) { +func (s *GaslessEstimateReqMessagesItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("public_key") - e.Str(s.PublicKey) + e.FieldStart("boc") + e.Str(s.Boc) } } -var jsonFieldsNameOfGetAccountPublicKeyOK = [1]string{ - 0: "public_key", +var jsonFieldsNameOfGaslessEstimateReqMessagesItem = [1]string{ + 0: "boc", } -// Decode decodes GetAccountPublicKeyOK from json. -func (s *GetAccountPublicKeyOK) Decode(d *jx.Decoder) error { +// Decode decodes GaslessEstimateReqMessagesItem from json. +func (s *GaslessEstimateReqMessagesItem) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetAccountPublicKeyOK to nil") + return errors.New("invalid: unable to decode GaslessEstimateReqMessagesItem to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "public_key": + case "boc": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.PublicKey = string(v) + s.Boc = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"public_key\"") + return errors.Wrap(err, "decode field \"boc\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetAccountPublicKeyOK") + return errors.Wrap(err, "decode GaslessEstimateReqMessagesItem") } // Validate required fields. var failures []validate.FieldError @@ -16419,8 +17928,8 @@ func (s *GetAccountPublicKeyOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetAccountPublicKeyOK) { - name = jsonFieldsNameOfGetAccountPublicKeyOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGaslessEstimateReqMessagesItem) { + name = jsonFieldsNameOfGaslessEstimateReqMessagesItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16441,81 +17950,86 @@ func (s *GetAccountPublicKeyOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetAccountPublicKeyOK) MarshalJSON() ([]byte, error) { +func (s *GaslessEstimateReqMessagesItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetAccountPublicKeyOK) UnmarshalJSON(data []byte) error { +func (s *GaslessEstimateReqMessagesItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetAccountsReq) Encode(e *jx.Encoder) { +func (s *GaslessSendReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetAccountsReq) encodeFields(e *jx.Encoder) { +func (s *GaslessSendReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("account_ids") - e.ArrStart() - for _, elem := range s.AccountIds { - e.Str(elem) - } - e.ArrEnd() + e.FieldStart("wallet_public_key") + e.Str(s.WalletPublicKey) + } + { + e.FieldStart("boc") + e.Str(s.Boc) } } -var jsonFieldsNameOfGetAccountsReq = [1]string{ - 0: "account_ids", +var jsonFieldsNameOfGaslessSendReq = [2]string{ + 0: "wallet_public_key", + 1: "boc", } -// Decode decodes GetAccountsReq from json. -func (s *GetAccountsReq) Decode(d *jx.Decoder) error { +// Decode decodes GaslessSendReq from json. +func (s *GaslessSendReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetAccountsReq to nil") + return errors.New("invalid: unable to decode GaslessSendReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "account_ids": + case "wallet_public_key": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.AccountIds = make([]string, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { - return err - } - s.AccountIds = append(s.AccountIds, elem) - return nil - }); err != nil { + v, err := d.Str() + s.WalletPublicKey = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"account_ids\"") + return errors.Wrap(err, "decode field \"wallet_public_key\"") + } + case "boc": + requiredBitSet[0] |= 1 << 1 + 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 GetAccountsReq") + return errors.Wrap(err, "decode GaslessSendReq") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -16527,8 +18041,8 @@ func (s *GetAccountsReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetAccountsReq) { - name = jsonFieldsNameOfGetAccountsReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGaslessSendReq) { + name = jsonFieldsNameOfGaslessSendReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16549,101 +18063,69 @@ func (s *GetAccountsReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetAccountsReq) MarshalJSON() ([]byte, error) { +func (s *GaslessSendReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetAccountsReq) UnmarshalJSON(data []byte) error { +func (s *GaslessSendReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetAllRawShardsInfoOK) Encode(e *jx.Encoder) { +func (s *GaslessTx) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetAllRawShardsInfoOK) encodeFields(e *jx.Encoder) { +func (s *GaslessTx) encodeFields(e *jx.Encoder) { { - e.FieldStart("id") - s.ID.Encode(e) - } - { - e.FieldStart("proof") - e.Str(s.Proof) - } - { - e.FieldStart("data") - e.Str(s.Data) + e.FieldStart("protocol_name") + e.Str(s.ProtocolName) } } -var jsonFieldsNameOfGetAllRawShardsInfoOK = [3]string{ - 0: "id", - 1: "proof", - 2: "data", +var jsonFieldsNameOfGaslessTx = [1]string{ + 0: "protocol_name", } -// Decode decodes GetAllRawShardsInfoOK from json. -func (s *GetAllRawShardsInfoOK) Decode(d *jx.Decoder) error { +// Decode decodes GaslessTx from json. +func (s *GaslessTx) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetAllRawShardsInfoOK to nil") + return errors.New("invalid: unable to decode GaslessTx to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "id": + case "protocol_name": requiredBitSet[0] |= 1 << 0 - if err := func() error { - if err := s.ID.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"id\"") - } - case "proof": - requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.Proof = string(v) + s.ProtocolName = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"proof\"") - } - case "data": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Str() - s.Data = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"data\"") + return errors.Wrap(err, "decode field \"protocol_name\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetAllRawShardsInfoOK") + return errors.Wrap(err, "decode GaslessTx") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -16655,8 +18137,8 @@ func (s *GetAllRawShardsInfoOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetAllRawShardsInfoOK) { - name = jsonFieldsNameOfGetAllRawShardsInfoOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGaslessTx) { + name = jsonFieldsNameOfGaslessTx[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16677,66 +18159,64 @@ func (s *GetAllRawShardsInfoOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetAllRawShardsInfoOK) MarshalJSON() ([]byte, error) { +func (s *GaslessTx) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetAllRawShardsInfoOK) UnmarshalJSON(data []byte) error { +func (s *GaslessTx) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetChartRatesOK) Encode(e *jx.Encoder) { +func (s *GetAccountDiffOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetChartRatesOK) encodeFields(e *jx.Encoder) { +func (s *GetAccountDiffOK) encodeFields(e *jx.Encoder) { { - if len(s.Points) != 0 { - e.FieldStart("points") - e.Raw(s.Points) - } + e.FieldStart("balance_change") + e.Int64(s.BalanceChange) } } -var jsonFieldsNameOfGetChartRatesOK = [1]string{ - 0: "points", +var jsonFieldsNameOfGetAccountDiffOK = [1]string{ + 0: "balance_change", } -// Decode decodes GetChartRatesOK from json. -func (s *GetChartRatesOK) Decode(d *jx.Decoder) error { +// Decode decodes GetAccountDiffOK from json. +func (s *GetAccountDiffOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetChartRatesOK to nil") + return errors.New("invalid: unable to decode GetAccountDiffOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "points": + case "balance_change": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.RawAppend(nil) - s.Points = jx.Raw(v) + v, err := d.Int64() + s.BalanceChange = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"points\"") + return errors.Wrap(err, "decode field \"balance_change\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetChartRatesOK") + return errors.Wrap(err, "decode GetAccountDiffOK") } // Validate required fields. var failures []validate.FieldError @@ -16753,8 +18233,8 @@ func (s *GetChartRatesOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetChartRatesOK) { - name = jsonFieldsNameOfGetChartRatesOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetAccountDiffOK) { + name = jsonFieldsNameOfGetAccountDiffOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16775,86 +18255,69 @@ func (s *GetChartRatesOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetChartRatesOK) MarshalJSON() ([]byte, error) { +func (s *GetAccountDiffOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetChartRatesOK) UnmarshalJSON(data []byte) error { +func (s *GetAccountDiffOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetInscriptionOpTemplateOK) Encode(e *jx.Encoder) { +func (s *GetAccountInfoByStateInitReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetInscriptionOpTemplateOK) encodeFields(e *jx.Encoder) { - { - e.FieldStart("comment") - e.Str(s.Comment) - } +func (s *GetAccountInfoByStateInitReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("destination") - e.Str(s.Destination) + e.FieldStart("state_init") + e.Str(s.StateInit) } } -var jsonFieldsNameOfGetInscriptionOpTemplateOK = [2]string{ - 0: "comment", - 1: "destination", +var jsonFieldsNameOfGetAccountInfoByStateInitReq = [1]string{ + 0: "state_init", } -// Decode decodes GetInscriptionOpTemplateOK from json. -func (s *GetInscriptionOpTemplateOK) Decode(d *jx.Decoder) error { +// Decode decodes GetAccountInfoByStateInitReq from json. +func (s *GetAccountInfoByStateInitReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetInscriptionOpTemplateOK to nil") + return errors.New("invalid: unable to decode GetAccountInfoByStateInitReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "comment": + case "state_init": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.Comment = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"comment\"") - } - case "destination": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Str() - s.Destination = string(v) + s.StateInit = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"destination\"") + return errors.Wrap(err, "decode field \"state_init\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetInscriptionOpTemplateOK") + return errors.Wrap(err, "decode GetAccountInfoByStateInitReq") } // 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. @@ -16866,8 +18329,8 @@ func (s *GetInscriptionOpTemplateOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetInscriptionOpTemplateOK) { - name = jsonFieldsNameOfGetInscriptionOpTemplateOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetAccountInfoByStateInitReq) { + name = jsonFieldsNameOfGetAccountInfoByStateInitReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16888,74 +18351,64 @@ func (s *GetInscriptionOpTemplateOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetInscriptionOpTemplateOK) MarshalJSON() ([]byte, error) { +func (s *GetAccountInfoByStateInitReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetInscriptionOpTemplateOK) UnmarshalJSON(data []byte) error { +func (s *GetAccountInfoByStateInitReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetMarketsRatesOK) Encode(e *jx.Encoder) { +func (s *GetAccountPublicKeyOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetMarketsRatesOK) encodeFields(e *jx.Encoder) { +func (s *GetAccountPublicKeyOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("markets") - e.ArrStart() - for _, elem := range s.Markets { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("public_key") + e.Str(s.PublicKey) } } -var jsonFieldsNameOfGetMarketsRatesOK = [1]string{ - 0: "markets", +var jsonFieldsNameOfGetAccountPublicKeyOK = [1]string{ + 0: "public_key", } -// Decode decodes GetMarketsRatesOK from json. -func (s *GetMarketsRatesOK) Decode(d *jx.Decoder) error { +// Decode decodes GetAccountPublicKeyOK from json. +func (s *GetAccountPublicKeyOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetMarketsRatesOK to nil") + return errors.New("invalid: unable to decode GetAccountPublicKeyOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "markets": + case "public_key": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Markets = make([]MarketTonRates, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem MarketTonRates - if err := elem.Decode(d); err != nil { - return err - } - s.Markets = append(s.Markets, elem) - return nil - }); err != nil { + v, err := d.Str() + s.PublicKey = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"markets\"") + return errors.Wrap(err, "decode field \"public_key\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetMarketsRatesOK") + return errors.Wrap(err, "decode GetAccountPublicKeyOK") } // Validate required fields. var failures []validate.FieldError @@ -16972,8 +18425,8 @@ func (s *GetMarketsRatesOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetMarketsRatesOK) { - name = jsonFieldsNameOfGetMarketsRatesOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetAccountPublicKeyOK) { + name = jsonFieldsNameOfGetAccountPublicKeyOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16994,27 +18447,27 @@ func (s *GetMarketsRatesOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetMarketsRatesOK) MarshalJSON() ([]byte, error) { +func (s *GetAccountPublicKeyOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetMarketsRatesOK) UnmarshalJSON(data []byte) error { +func (s *GetAccountPublicKeyOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetNftItemsByAddressesReq) Encode(e *jx.Encoder) { +func (s *GetAccountsReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetNftItemsByAddressesReq) encodeFields(e *jx.Encoder) { +func (s *GetAccountsReq) encodeFields(e *jx.Encoder) { { e.FieldStart("account_ids") e.ArrStart() @@ -17025,14 +18478,14 @@ func (s *GetNftItemsByAddressesReq) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfGetNftItemsByAddressesReq = [1]string{ +var jsonFieldsNameOfGetAccountsReq = [1]string{ 0: "account_ids", } -// Decode decodes GetNftItemsByAddressesReq from json. -func (s *GetNftItemsByAddressesReq) Decode(d *jx.Decoder) error { +// Decode decodes GetAccountsReq from json. +func (s *GetAccountsReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetNftItemsByAddressesReq to nil") + return errors.New("invalid: unable to decode GetAccountsReq to nil") } var requiredBitSet [1]uint8 @@ -17063,7 +18516,7 @@ func (s *GetNftItemsByAddressesReq) Decode(d *jx.Decoder) error { } return nil }); err != nil { - return errors.Wrap(err, "decode GetNftItemsByAddressesReq") + return errors.Wrap(err, "decode GetAccountsReq") } // Validate required fields. var failures []validate.FieldError @@ -17080,8 +18533,8 @@ func (s *GetNftItemsByAddressesReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetNftItemsByAddressesReq) { - name = jsonFieldsNameOfGetNftItemsByAddressesReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetAccountsReq) { + name = jsonFieldsNameOfGetAccountsReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17102,96 +18555,101 @@ func (s *GetNftItemsByAddressesReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetNftItemsByAddressesReq) MarshalJSON() ([]byte, error) { +func (s *GetAccountsReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetNftItemsByAddressesReq) UnmarshalJSON(data []byte) error { +func (s *GetAccountsReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetOutMsgQueueSizesOK) Encode(e *jx.Encoder) { +func (s *GetAllRawShardsInfoOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetOutMsgQueueSizesOK) encodeFields(e *jx.Encoder) { +func (s *GetAllRawShardsInfoOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("ext_msg_queue_size_limit") - e.UInt32(s.ExtMsgQueueSizeLimit) + e.FieldStart("id") + s.ID.Encode(e) } { - e.FieldStart("shards") - e.ArrStart() - for _, elem := range s.Shards { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("proof") + e.Str(s.Proof) + } + { + e.FieldStart("data") + e.Str(s.Data) } } -var jsonFieldsNameOfGetOutMsgQueueSizesOK = [2]string{ - 0: "ext_msg_queue_size_limit", - 1: "shards", +var jsonFieldsNameOfGetAllRawShardsInfoOK = [3]string{ + 0: "id", + 1: "proof", + 2: "data", } -// Decode decodes GetOutMsgQueueSizesOK from json. -func (s *GetOutMsgQueueSizesOK) Decode(d *jx.Decoder) error { +// Decode decodes GetAllRawShardsInfoOK from json. +func (s *GetAllRawShardsInfoOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetOutMsgQueueSizesOK to nil") + return errors.New("invalid: unable to decode GetAllRawShardsInfoOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "ext_msg_queue_size_limit": + case "id": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.UInt32() - s.ExtMsgQueueSizeLimit = uint32(v) - if err != nil { + if err := s.ID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ext_msg_queue_size_limit\"") + return errors.Wrap(err, "decode field \"id\"") } - case "shards": + case "proof": requiredBitSet[0] |= 1 << 1 if err := func() error { - s.Shards = make([]GetOutMsgQueueSizesOKShardsItem, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem GetOutMsgQueueSizesOKShardsItem - if err := elem.Decode(d); err != nil { - return err - } - s.Shards = append(s.Shards, elem) - return nil - }); err != nil { + v, err := d.Str() + s.Proof = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"shards\"") + return errors.Wrap(err, "decode field \"proof\"") + } + case "data": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Data = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"data\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetOutMsgQueueSizesOK") + return errors.Wrap(err, "decode GetAllRawShardsInfoOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000011, + 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -17203,8 +18661,8 @@ func (s *GetOutMsgQueueSizesOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetOutMsgQueueSizesOK) { - name = jsonFieldsNameOfGetOutMsgQueueSizesOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetAllRawShardsInfoOK) { + name = jsonFieldsNameOfGetAllRawShardsInfoOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17225,84 +18683,67 @@ func (s *GetOutMsgQueueSizesOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetOutMsgQueueSizesOK) MarshalJSON() ([]byte, error) { +func (s *GetAllRawShardsInfoOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetOutMsgQueueSizesOK) UnmarshalJSON(data []byte) error { +func (s *GetAllRawShardsInfoOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetOutMsgQueueSizesOKShardsItem) Encode(e *jx.Encoder) { +func (s *GetChartRatesOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetOutMsgQueueSizesOKShardsItem) encodeFields(e *jx.Encoder) { - { - e.FieldStart("id") - s.ID.Encode(e) - } +func (s *GetChartRatesOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("size") - e.UInt32(s.Size) + e.FieldStart("points") + s.Points.Encode(e) } } -var jsonFieldsNameOfGetOutMsgQueueSizesOKShardsItem = [2]string{ - 0: "id", - 1: "size", +var jsonFieldsNameOfGetChartRatesOK = [1]string{ + 0: "points", } -// Decode decodes GetOutMsgQueueSizesOKShardsItem from json. -func (s *GetOutMsgQueueSizesOKShardsItem) Decode(d *jx.Decoder) error { +// Decode decodes GetChartRatesOK from json. +func (s *GetChartRatesOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetOutMsgQueueSizesOKShardsItem to nil") + return errors.New("invalid: unable to decode GetChartRatesOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "id": + case "points": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.ID.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"id\"") - } - case "size": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.UInt32() - s.Size = uint32(v) - if err != nil { + if err := s.Points.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"size\"") + return errors.Wrap(err, "decode field \"points\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetOutMsgQueueSizesOKShardsItem") + return errors.Wrap(err, "decode GetChartRatesOK") } // 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. @@ -17314,8 +18755,8 @@ func (s *GetOutMsgQueueSizesOKShardsItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetOutMsgQueueSizesOKShardsItem) { - name = jsonFieldsNameOfGetOutMsgQueueSizesOKShardsItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetChartRatesOK) { + name = jsonFieldsNameOfGetChartRatesOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17336,62 +18777,76 @@ func (s *GetOutMsgQueueSizesOKShardsItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetOutMsgQueueSizesOKShardsItem) MarshalJSON() ([]byte, error) { +func (s *GetChartRatesOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetOutMsgQueueSizesOKShardsItem) UnmarshalJSON(data []byte) error { +func (s *GetChartRatesOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRatesOK) Encode(e *jx.Encoder) { +func (s *GetJettonInfosByAddressesReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRatesOK) encodeFields(e *jx.Encoder) { +func (s *GetJettonInfosByAddressesReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("rates") - s.Rates.Encode(e) + e.FieldStart("account_ids") + e.ArrStart() + for _, elem := range s.AccountIds { + e.Str(elem) + } + e.ArrEnd() } } -var jsonFieldsNameOfGetRatesOK = [1]string{ - 0: "rates", +var jsonFieldsNameOfGetJettonInfosByAddressesReq = [1]string{ + 0: "account_ids", } -// Decode decodes GetRatesOK from json. -func (s *GetRatesOK) Decode(d *jx.Decoder) error { +// Decode decodes GetJettonInfosByAddressesReq from json. +func (s *GetJettonInfosByAddressesReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRatesOK to nil") + return errors.New("invalid: unable to decode GetJettonInfosByAddressesReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "rates": + case "account_ids": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Rates.Decode(d); err != nil { + s.AccountIds = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.AccountIds = append(s.AccountIds, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"rates\"") + return errors.Wrap(err, "decode field \"account_ids\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRatesOK") + return errors.Wrap(err, "decode GetJettonInfosByAddressesReq") } // Validate required fields. var failures []validate.FieldError @@ -17408,8 +18863,8 @@ func (s *GetRatesOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRatesOK) { - name = jsonFieldsNameOfGetRatesOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetJettonInfosByAddressesReq) { + name = jsonFieldsNameOfGetJettonInfosByAddressesReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17430,187 +18885,79 @@ func (s *GetRatesOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRatesOK) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRatesOK) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s GetRatesOKRates) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields implements json.Marshaler. -func (s GetRatesOKRates) encodeFields(e *jx.Encoder) { - for k, elem := range s { - e.FieldStart(k) - - elem.Encode(e) - } -} - -// Decode decodes GetRatesOKRates from json. -func (s *GetRatesOKRates) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode GetRatesOKRates to nil") - } - m := s.init() - if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - var elem TokenRates - if err := func() error { - if err := elem.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrapf(err, "decode field %q", k) - } - m[string(k)] = elem - return nil - }); err != nil { - return errors.Wrap(err, "decode GetRatesOKRates") - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s GetRatesOKRates) MarshalJSON() ([]byte, error) { +func (s *GetJettonInfosByAddressesReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRatesOKRates) UnmarshalJSON(data []byte) error { +func (s *GetJettonInfosByAddressesReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawAccountStateOK) Encode(e *jx.Encoder) { +func (s *GetMarketsRatesOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawAccountStateOK) encodeFields(e *jx.Encoder) { - { - e.FieldStart("id") - s.ID.Encode(e) - } - { - e.FieldStart("shardblk") - s.Shardblk.Encode(e) - } - { - e.FieldStart("shard_proof") - e.Str(s.ShardProof) - } - { - e.FieldStart("proof") - e.Str(s.Proof) - } +func (s *GetMarketsRatesOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("state") - e.Str(s.State) + e.FieldStart("markets") + e.ArrStart() + for _, elem := range s.Markets { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfGetRawAccountStateOK = [5]string{ - 0: "id", - 1: "shardblk", - 2: "shard_proof", - 3: "proof", - 4: "state", +var jsonFieldsNameOfGetMarketsRatesOK = [1]string{ + 0: "markets", } -// Decode decodes GetRawAccountStateOK from json. -func (s *GetRawAccountStateOK) Decode(d *jx.Decoder) error { +// Decode decodes GetMarketsRatesOK from json. +func (s *GetMarketsRatesOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawAccountStateOK to nil") + return errors.New("invalid: unable to decode GetMarketsRatesOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "id": + case "markets": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.ID.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"id\"") - } - case "shardblk": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - if err := s.Shardblk.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"shardblk\"") - } - case "shard_proof": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Str() - s.ShardProof = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"shard_proof\"") - } - case "proof": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Str() - s.Proof = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"proof\"") - } - case "state": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Str() - s.State = string(v) - if err != nil { + s.Markets = make([]MarketTonRates, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem MarketTonRates + if err := elem.Decode(d); err != nil { + return err + } + s.Markets = append(s.Markets, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"state\"") + return errors.Wrap(err, "decode field \"markets\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawAccountStateOK") + return errors.Wrap(err, "decode GetMarketsRatesOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00011111, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -17622,8 +18969,8 @@ func (s *GetRawAccountStateOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawAccountStateOK) { - name = jsonFieldsNameOfGetRawAccountStateOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetMarketsRatesOK) { + name = jsonFieldsNameOfGetMarketsRatesOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17644,126 +18991,81 @@ func (s *GetRawAccountStateOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawAccountStateOK) MarshalJSON() ([]byte, error) { +func (s *GetMarketsRatesOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawAccountStateOK) UnmarshalJSON(data []byte) error { +func (s *GetMarketsRatesOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawBlockProofOK) Encode(e *jx.Encoder) { +func (s *GetNftCollectionItemsByAddressesReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockProofOK) encodeFields(e *jx.Encoder) { - { - e.FieldStart("complete") - e.Bool(s.Complete) - } +func (s *GetNftCollectionItemsByAddressesReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("from") - s.From.Encode(e) - } - { - e.FieldStart("to") - s.To.Encode(e) - } - { - e.FieldStart("steps") + e.FieldStart("account_ids") e.ArrStart() - for _, elem := range s.Steps { - elem.Encode(e) + for _, elem := range s.AccountIds { + e.Str(elem) } e.ArrEnd() } } -var jsonFieldsNameOfGetRawBlockProofOK = [4]string{ - 0: "complete", - 1: "from", - 2: "to", - 3: "steps", +var jsonFieldsNameOfGetNftCollectionItemsByAddressesReq = [1]string{ + 0: "account_ids", } -// Decode decodes GetRawBlockProofOK from json. -func (s *GetRawBlockProofOK) Decode(d *jx.Decoder) error { +// Decode decodes GetNftCollectionItemsByAddressesReq from json. +func (s *GetNftCollectionItemsByAddressesReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawBlockProofOK to nil") + return errors.New("invalid: unable to decode GetNftCollectionItemsByAddressesReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "complete": + case "account_ids": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Bool() - s.Complete = bool(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"complete\"") - } - case "from": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - if err := s.From.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"from\"") - } - case "to": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - if err := s.To.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"to\"") - } - case "steps": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - s.Steps = make([]GetRawBlockProofOKStepsItem, 0) + s.AccountIds = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem GetRawBlockProofOKStepsItem - if err := elem.Decode(d); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } - s.Steps = append(s.Steps, elem) + s.AccountIds = append(s.AccountIds, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"steps\"") + return errors.Wrap(err, "decode field \"account_ids\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockProofOK") + return errors.Wrap(err, "decode GetNftCollectionItemsByAddressesReq") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001111, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -17775,8 +19077,8 @@ func (s *GetRawBlockProofOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOK) { - name = jsonFieldsNameOfGetRawBlockProofOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetNftCollectionItemsByAddressesReq) { + name = jsonFieldsNameOfGetNftCollectionItemsByAddressesReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17797,82 +19099,81 @@ func (s *GetRawBlockProofOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockProofOK) MarshalJSON() ([]byte, error) { +func (s *GetNftCollectionItemsByAddressesReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawBlockProofOK) UnmarshalJSON(data []byte) error { +func (s *GetNftCollectionItemsByAddressesReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawBlockProofOKStepsItem) Encode(e *jx.Encoder) { +func (s *GetNftItemsByAddressesReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockProofOKStepsItem) encodeFields(e *jx.Encoder) { - { - e.FieldStart("lite_server_block_link_back") - s.LiteServerBlockLinkBack.Encode(e) - } +func (s *GetNftItemsByAddressesReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("lite_server_block_link_forward") - s.LiteServerBlockLinkForward.Encode(e) + e.FieldStart("account_ids") + e.ArrStart() + for _, elem := range s.AccountIds { + e.Str(elem) + } + e.ArrEnd() } } -var jsonFieldsNameOfGetRawBlockProofOKStepsItem = [2]string{ - 0: "lite_server_block_link_back", - 1: "lite_server_block_link_forward", +var jsonFieldsNameOfGetNftItemsByAddressesReq = [1]string{ + 0: "account_ids", } -// Decode decodes GetRawBlockProofOKStepsItem from json. -func (s *GetRawBlockProofOKStepsItem) Decode(d *jx.Decoder) error { +// Decode decodes GetNftItemsByAddressesReq from json. +func (s *GetNftItemsByAddressesReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawBlockProofOKStepsItem to nil") + return errors.New("invalid: unable to decode GetNftItemsByAddressesReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "lite_server_block_link_back": + case "account_ids": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.LiteServerBlockLinkBack.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"lite_server_block_link_back\"") - } - case "lite_server_block_link_forward": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - if err := s.LiteServerBlockLinkForward.Decode(d); err != nil { + s.AccountIds = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.AccountIds = append(s.AccountIds, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"lite_server_block_link_forward\"") + return errors.Wrap(err, "decode field \"account_ids\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockProofOKStepsItem") + return errors.Wrap(err, "decode GetNftItemsByAddressesReq") } // 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. @@ -17884,8 +19185,8 @@ func (s *GetRawBlockProofOKStepsItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOKStepsItem) { - name = jsonFieldsNameOfGetRawBlockProofOKStepsItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetNftItemsByAddressesReq) { + name = jsonFieldsNameOfGetNftItemsByAddressesReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17906,150 +19207,96 @@ func (s *GetRawBlockProofOKStepsItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockProofOKStepsItem) MarshalJSON() ([]byte, error) { +func (s *GetNftItemsByAddressesReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawBlockProofOKStepsItem) UnmarshalJSON(data []byte) error { +func (s *GetNftItemsByAddressesReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) Encode(e *jx.Encoder) { +func (s *GetOutMsgQueueSizesOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) encodeFields(e *jx.Encoder) { +func (s *GetOutMsgQueueSizesOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("to_key_block") - e.Bool(s.ToKeyBlock) + e.FieldStart("ext_msg_queue_size_limit") + e.UInt32(s.ExtMsgQueueSizeLimit) } { - e.FieldStart("from") - s.From.Encode(e) - } - { - e.FieldStart("to") - s.To.Encode(e) - } - { - e.FieldStart("dest_proof") - e.Str(s.DestProof) - } - { - e.FieldStart("proof") - e.Str(s.Proof) - } - { - e.FieldStart("state_proof") - e.Str(s.StateProof) + e.FieldStart("shards") + e.ArrStart() + for _, elem := range s.Shards { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkBack = [6]string{ - 0: "to_key_block", - 1: "from", - 2: "to", - 3: "dest_proof", - 4: "proof", - 5: "state_proof", +var jsonFieldsNameOfGetOutMsgQueueSizesOK = [2]string{ + 0: "ext_msg_queue_size_limit", + 1: "shards", } -// Decode decodes GetRawBlockProofOKStepsItemLiteServerBlockLinkBack from json. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) Decode(d *jx.Decoder) error { +// Decode decodes GetOutMsgQueueSizesOK from json. +func (s *GetOutMsgQueueSizesOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawBlockProofOKStepsItemLiteServerBlockLinkBack to nil") + return errors.New("invalid: unable to decode GetOutMsgQueueSizesOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "to_key_block": + case "ext_msg_queue_size_limit": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Bool() - s.ToKeyBlock = bool(v) + v, err := d.UInt32() + s.ExtMsgQueueSizeLimit = uint32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"to_key_block\"") + return errors.Wrap(err, "decode field \"ext_msg_queue_size_limit\"") } - case "from": + case "shards": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.From.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"from\"") - } - case "to": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - if err := s.To.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"to\"") - } - case "dest_proof": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Str() - s.DestProof = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"dest_proof\"") - } - case "proof": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Str() - s.Proof = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"proof\"") - } - case "state_proof": - requiredBitSet[0] |= 1 << 5 - if err := func() error { - v, err := d.Str() - s.StateProof = string(v) - if err != nil { + s.Shards = make([]GetOutMsgQueueSizesOKShardsItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem GetOutMsgQueueSizesOKShardsItem + if err := elem.Decode(d); err != nil { + return err + } + s.Shards = append(s.Shards, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"state_proof\"") + return errors.Wrap(err, "decode field \"shards\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkBack") + return errors.Wrap(err, "decode GetOutMsgQueueSizesOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00111111, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -18061,8 +19308,8 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) Decode(d *jx.Decode bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkBack) { - name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkBack[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetOutMsgQueueSizesOK) { + name = jsonFieldsNameOfGetOutMsgQueueSizesOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -18083,148 +19330,84 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) Decode(d *jx.Decode } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) MarshalJSON() ([]byte, error) { +func (s *GetOutMsgQueueSizesOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) UnmarshalJSON(data []byte) error { +func (s *GetOutMsgQueueSizesOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) Encode(e *jx.Encoder) { +func (s *GetOutMsgQueueSizesOKShardsItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) encodeFields(e *jx.Encoder) { - { - e.FieldStart("to_key_block") - e.Bool(s.ToKeyBlock) - } - { - e.FieldStart("from") - s.From.Encode(e) - } - { - e.FieldStart("to") - s.To.Encode(e) - } - { - e.FieldStart("dest_proof") - e.Str(s.DestProof) - } +func (s *GetOutMsgQueueSizesOKShardsItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("config_proof") - e.Str(s.ConfigProof) + e.FieldStart("id") + s.ID.Encode(e) } { - e.FieldStart("signatures") - s.Signatures.Encode(e) + e.FieldStart("size") + e.UInt32(s.Size) } } -var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForward = [6]string{ - 0: "to_key_block", - 1: "from", - 2: "to", - 3: "dest_proof", - 4: "config_proof", - 5: "signatures", +var jsonFieldsNameOfGetOutMsgQueueSizesOKShardsItem = [2]string{ + 0: "id", + 1: "size", } -// Decode decodes GetRawBlockProofOKStepsItemLiteServerBlockLinkForward from json. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) Decode(d *jx.Decoder) error { +// Decode decodes GetOutMsgQueueSizesOKShardsItem from json. +func (s *GetOutMsgQueueSizesOKShardsItem) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForward to nil") + return errors.New("invalid: unable to decode GetOutMsgQueueSizesOKShardsItem to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "to_key_block": + case "id": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Bool() - s.ToKeyBlock = bool(v) - if err != nil { + if err := s.ID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"to_key_block\"") + return errors.Wrap(err, "decode field \"id\"") } - case "from": + case "size": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.From.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"from\"") - } - case "to": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - if err := s.To.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"to\"") - } - case "dest_proof": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Str() - s.DestProof = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"dest_proof\"") - } - case "config_proof": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Str() - s.ConfigProof = string(v) + v, err := d.UInt32() + s.Size = uint32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"config_proof\"") - } - case "signatures": - requiredBitSet[0] |= 1 << 5 - if err := func() error { - if err := s.Signatures.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"signatures\"") + return errors.Wrap(err, "decode field \"size\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForward") + return errors.Wrap(err, "decode GetOutMsgQueueSizesOKShardsItem") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00111111, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -18236,8 +19419,8 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) Decode(d *jx.Dec bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForward) { - name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForward[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetOutMsgQueueSizesOKShardsItem) { + name = jsonFieldsNameOfGetOutMsgQueueSizesOKShardsItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -18258,113 +19441,67 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) Decode(d *jx.Dec } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) MarshalJSON() ([]byte, error) { +func (s *GetOutMsgQueueSizesOKShardsItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) UnmarshalJSON(data []byte) error { +func (s *GetOutMsgQueueSizesOKShardsItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) Encode(e *jx.Encoder) { +func (s *GetRatesOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) encodeFields(e *jx.Encoder) { - { - e.FieldStart("validator_set_hash") - e.Int64(s.ValidatorSetHash) - } - { - e.FieldStart("catchain_seqno") - e.Int32(s.CatchainSeqno) - } +func (s *GetRatesOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("signatures") - e.ArrStart() - for _, elem := range s.Signatures { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("rates") + s.Rates.Encode(e) } } -var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures = [3]string{ - 0: "validator_set_hash", - 1: "catchain_seqno", - 2: "signatures", +var jsonFieldsNameOfGetRatesOK = [1]string{ + 0: "rates", } -// Decode decodes GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures from json. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) Decode(d *jx.Decoder) error { +// Decode decodes GetRatesOK from json. +func (s *GetRatesOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures to nil") + return errors.New("invalid: unable to decode GetRatesOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "validator_set_hash": + case "rates": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.ValidatorSetHash = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"validator_set_hash\"") - } - case "catchain_seqno": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Int32() - s.CatchainSeqno = int32(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"catchain_seqno\"") - } - case "signatures": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - s.Signatures = make([]GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem - if err := elem.Decode(d); err != nil { - return err - } - s.Signatures = append(s.Signatures, elem) - return nil - }); err != nil { + if err := s.Rates.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"signatures\"") + return errors.Wrap(err, "decode field \"rates\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures") + return errors.Wrap(err, "decode GetRatesOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -18376,8 +19513,8 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) Decode bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) { - name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRatesOK) { + name = jsonFieldsNameOfGetRatesOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -18398,164 +19535,115 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) Decode } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) MarshalJSON() ([]byte, error) { +func (s *GetRatesOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) UnmarshalJSON(data []byte) error { +func (s *GetRatesOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) Encode(e *jx.Encoder) { +func (s GetRatesOKRates) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields encodes fields. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) encodeFields(e *jx.Encoder) { - { - e.FieldStart("node_id_short") - e.Str(s.NodeIDShort) - } - { - e.FieldStart("signature") - e.Str(s.Signature) - } -} +// encodeFields implements json.Marshaler. +func (s GetRatesOKRates) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) -var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem = [2]string{ - 0: "node_id_short", - 1: "signature", + elem.Encode(e) + } } -// Decode decodes GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem from json. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) Decode(d *jx.Decoder) error { +// Decode decodes GetRatesOKRates from json. +func (s *GetRatesOKRates) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem to nil") + return errors.New("invalid: unable to decode GetRatesOKRates to nil") } - var requiredBitSet [1]uint8 - + m := s.init() if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - switch string(k) { - case "node_id_short": - requiredBitSet[0] |= 1 << 0 - if err := func() error { - v, err := d.Str() - s.NodeIDShort = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"node_id_short\"") - } - case "signature": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Str() - s.Signature = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"signature\"") + var elem TokenRates + if err := func() error { + if err := elem.Decode(d); err != nil { + return err } - default: - return d.Skip() + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) } + m[string(k)] = elem return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem") - } - // 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(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) { - name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem[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 errors.Wrap(err, "decode GetRatesOKRates") } return nil } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) MarshalJSON() ([]byte, error) { +func (s GetRatesOKRates) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) UnmarshalJSON(data []byte) error { +func (s *GetRatesOKRates) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawBlockchainBlockHeaderOK) Encode(e *jx.Encoder) { +func (s *GetRawAccountStateOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockchainBlockHeaderOK) encodeFields(e *jx.Encoder) { +func (s *GetRawAccountStateOK) encodeFields(e *jx.Encoder) { { e.FieldStart("id") s.ID.Encode(e) } { - e.FieldStart("mode") - e.Int32(s.Mode) + e.FieldStart("shardblk") + s.Shardblk.Encode(e) } { - e.FieldStart("header_proof") - e.Str(s.HeaderProof) + e.FieldStart("shard_proof") + e.Str(s.ShardProof) + } + { + e.FieldStart("proof") + e.Str(s.Proof) + } + { + e.FieldStart("state") + e.Str(s.State) } } -var jsonFieldsNameOfGetRawBlockchainBlockHeaderOK = [3]string{ +var jsonFieldsNameOfGetRawAccountStateOK = [5]string{ 0: "id", - 1: "mode", - 2: "header_proof", + 1: "shardblk", + 2: "shard_proof", + 3: "proof", + 4: "state", } -// Decode decodes GetRawBlockchainBlockHeaderOK from json. -func (s *GetRawBlockchainBlockHeaderOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawAccountStateOK from json. +func (s *GetRawAccountStateOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawBlockchainBlockHeaderOK to nil") + return errors.New("invalid: unable to decode GetRawAccountStateOK to nil") } var requiredBitSet [1]uint8 @@ -18571,41 +19659,63 @@ func (s *GetRawBlockchainBlockHeaderOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"id\"") } - case "mode": + case "shardblk": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int32() - s.Mode = int32(v) - if err != nil { + if err := s.Shardblk.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"mode\"") + return errors.Wrap(err, "decode field \"shardblk\"") } - case "header_proof": + case "shard_proof": requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.HeaderProof = string(v) + s.ShardProof = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"header_proof\"") + return errors.Wrap(err, "decode field \"shard_proof\"") + } + case "proof": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.Proof = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"proof\"") + } + case "state": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Str() + s.State = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"state\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockchainBlockHeaderOK") + return errors.Wrap(err, "decode GetRawAccountStateOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b00011111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -18617,8 +19727,8 @@ func (s *GetRawBlockchainBlockHeaderOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawBlockchainBlockHeaderOK) { - name = jsonFieldsNameOfGetRawBlockchainBlockHeaderOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawAccountStateOK) { + name = jsonFieldsNameOfGetRawAccountStateOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -18639,84 +19749,126 @@ func (s *GetRawBlockchainBlockHeaderOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockchainBlockHeaderOK) MarshalJSON() ([]byte, error) { +func (s *GetRawAccountStateOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawBlockchainBlockHeaderOK) UnmarshalJSON(data []byte) error { +func (s *GetRawAccountStateOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawBlockchainBlockOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockProofOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockchainBlockOK) encodeFields(e *jx.Encoder) { +func (s *GetRawBlockProofOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("id") - s.ID.Encode(e) + e.FieldStart("complete") + e.Bool(s.Complete) } { - e.FieldStart("data") - e.Str(s.Data) + e.FieldStart("from") + s.From.Encode(e) } -} - -var jsonFieldsNameOfGetRawBlockchainBlockOK = [2]string{ - 0: "id", - 1: "data", -} - -// Decode decodes GetRawBlockchainBlockOK from json. -func (s *GetRawBlockchainBlockOK) Decode(d *jx.Decoder) error { + { + e.FieldStart("to") + s.To.Encode(e) + } + { + e.FieldStart("steps") + e.ArrStart() + for _, elem := range s.Steps { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfGetRawBlockProofOK = [4]string{ + 0: "complete", + 1: "from", + 2: "to", + 3: "steps", +} + +// Decode decodes GetRawBlockProofOK from json. +func (s *GetRawBlockProofOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawBlockchainBlockOK to nil") + return errors.New("invalid: unable to decode GetRawBlockProofOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "id": + case "complete": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.ID.Decode(d); err != nil { + v, err := d.Bool() + s.Complete = bool(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"id\"") + return errors.Wrap(err, "decode field \"complete\"") } - case "data": + case "from": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.Data = string(v) - if err != nil { + if err := s.From.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"data\"") + return errors.Wrap(err, "decode field \"from\"") + } + case "to": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.To.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"to\"") + } + case "steps": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + s.Steps = make([]GetRawBlockProofOKStepsItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem GetRawBlockProofOKStepsItem + if err := elem.Decode(d); err != nil { + return err + } + s.Steps = append(s.Steps, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"steps\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockchainBlockOK") + return errors.Wrap(err, "decode GetRawBlockProofOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000011, + 0b00001111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -18728,8 +19880,8 @@ func (s *GetRawBlockchainBlockOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawBlockchainBlockOK) { - name = jsonFieldsNameOfGetRawBlockchainBlockOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOK) { + name = jsonFieldsNameOfGetRawBlockProofOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -18750,118 +19902,82 @@ func (s *GetRawBlockchainBlockOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockchainBlockOK) MarshalJSON() ([]byte, error) { +func (s *GetRawBlockProofOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawBlockchainBlockOK) UnmarshalJSON(data []byte) error { +func (s *GetRawBlockProofOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawBlockchainBlockStateOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockchainBlockStateOK) encodeFields(e *jx.Encoder) { - { - e.FieldStart("id") - s.ID.Encode(e) - } - { - e.FieldStart("root_hash") - e.Str(s.RootHash) - } +func (s *GetRawBlockProofOKStepsItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("file_hash") - e.Str(s.FileHash) + e.FieldStart("lite_server_block_link_back") + s.LiteServerBlockLinkBack.Encode(e) } { - e.FieldStart("data") - e.Str(s.Data) + e.FieldStart("lite_server_block_link_forward") + s.LiteServerBlockLinkForward.Encode(e) } } -var jsonFieldsNameOfGetRawBlockchainBlockStateOK = [4]string{ - 0: "id", - 1: "root_hash", - 2: "file_hash", - 3: "data", +var jsonFieldsNameOfGetRawBlockProofOKStepsItem = [2]string{ + 0: "lite_server_block_link_back", + 1: "lite_server_block_link_forward", } -// Decode decodes GetRawBlockchainBlockStateOK from json. -func (s *GetRawBlockchainBlockStateOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawBlockProofOKStepsItem from json. +func (s *GetRawBlockProofOKStepsItem) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawBlockchainBlockStateOK to nil") + return errors.New("invalid: unable to decode GetRawBlockProofOKStepsItem to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "id": + case "lite_server_block_link_back": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.ID.Decode(d); err != nil { + if err := s.LiteServerBlockLinkBack.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"id\"") + return errors.Wrap(err, "decode field \"lite_server_block_link_back\"") } - case "root_hash": + case "lite_server_block_link_forward": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.RootHash = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"root_hash\"") - } - case "file_hash": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Str() - s.FileHash = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"file_hash\"") - } - case "data": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Str() - s.Data = string(v) - if err != nil { + if err := s.LiteServerBlockLinkForward.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"data\"") + return errors.Wrap(err, "decode field \"lite_server_block_link_forward\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockchainBlockStateOK") + return errors.Wrap(err, "decode GetRawBlockProofOKStepsItem") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001111, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -18873,8 +19989,8 @@ func (s *GetRawBlockchainBlockStateOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawBlockchainBlockStateOK) { - name = jsonFieldsNameOfGetRawBlockchainBlockStateOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOKStepsItem) { + name = jsonFieldsNameOfGetRawBlockProofOKStepsItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -18895,118 +20011,150 @@ func (s *GetRawBlockchainBlockStateOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockchainBlockStateOK) MarshalJSON() ([]byte, error) { +func (s *GetRawBlockProofOKStepsItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawBlockchainBlockStateOK) UnmarshalJSON(data []byte) error { +func (s *GetRawBlockProofOKStepsItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawConfigOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawConfigOK) encodeFields(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) encodeFields(e *jx.Encoder) { { - e.FieldStart("mode") - e.Int32(s.Mode) + e.FieldStart("to_key_block") + e.Bool(s.ToKeyBlock) } { - e.FieldStart("id") - s.ID.Encode(e) + e.FieldStart("from") + s.From.Encode(e) } { - e.FieldStart("state_proof") - e.Str(s.StateProof) + e.FieldStart("to") + s.To.Encode(e) } { - e.FieldStart("config_proof") - e.Str(s.ConfigProof) + e.FieldStart("dest_proof") + e.Str(s.DestProof) + } + { + e.FieldStart("proof") + e.Str(s.Proof) + } + { + e.FieldStart("state_proof") + e.Str(s.StateProof) } } -var jsonFieldsNameOfGetRawConfigOK = [4]string{ - 0: "mode", - 1: "id", - 2: "state_proof", - 3: "config_proof", +var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkBack = [6]string{ + 0: "to_key_block", + 1: "from", + 2: "to", + 3: "dest_proof", + 4: "proof", + 5: "state_proof", } -// Decode decodes GetRawConfigOK from json. -func (s *GetRawConfigOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawBlockProofOKStepsItemLiteServerBlockLinkBack from json. +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawConfigOK to nil") + return errors.New("invalid: unable to decode GetRawBlockProofOKStepsItemLiteServerBlockLinkBack to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "mode": + case "to_key_block": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int32() - s.Mode = int32(v) + v, err := d.Bool() + s.ToKeyBlock = bool(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"mode\"") + return errors.Wrap(err, "decode field \"to_key_block\"") } - case "id": + case "from": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.ID.Decode(d); err != nil { + if err := s.From.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"id\"") + return errors.Wrap(err, "decode field \"from\"") } - case "state_proof": + case "to": requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.To.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"to\"") + } + case "dest_proof": + requiredBitSet[0] |= 1 << 3 if err := func() error { v, err := d.Str() - s.StateProof = string(v) + s.DestProof = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"state_proof\"") + return errors.Wrap(err, "decode field \"dest_proof\"") } - case "config_proof": - requiredBitSet[0] |= 1 << 3 + case "proof": + requiredBitSet[0] |= 1 << 4 if err := func() error { v, err := d.Str() - s.ConfigProof = string(v) + s.Proof = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"config_proof\"") + return errors.Wrap(err, "decode field \"proof\"") + } + case "state_proof": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Str() + s.StateProof = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"state_proof\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawConfigOK") + return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkBack") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001111, + 0b00111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -19018,8 +20166,8 @@ func (s *GetRawConfigOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawConfigOK) { - name = jsonFieldsNameOfGetRawConfigOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkBack) { + name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkBack[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19040,145 +20188,148 @@ func (s *GetRawConfigOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawConfigOK) MarshalJSON() ([]byte, error) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawConfigOK) UnmarshalJSON(data []byte) error { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawListBlockTransactionsOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawListBlockTransactionsOK) encodeFields(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) encodeFields(e *jx.Encoder) { { - e.FieldStart("id") - s.ID.Encode(e) + e.FieldStart("to_key_block") + e.Bool(s.ToKeyBlock) } { - e.FieldStart("req_count") - e.Int32(s.ReqCount) + e.FieldStart("from") + s.From.Encode(e) } { - e.FieldStart("incomplete") - e.Bool(s.Incomplete) + e.FieldStart("to") + s.To.Encode(e) } { - e.FieldStart("ids") - e.ArrStart() - for _, elem := range s.Ids { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("dest_proof") + e.Str(s.DestProof) } { - e.FieldStart("proof") - e.Str(s.Proof) + e.FieldStart("config_proof") + e.Str(s.ConfigProof) + } + { + e.FieldStart("signatures") + s.Signatures.Encode(e) } } -var jsonFieldsNameOfGetRawListBlockTransactionsOK = [5]string{ - 0: "id", - 1: "req_count", - 2: "incomplete", - 3: "ids", - 4: "proof", +var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForward = [6]string{ + 0: "to_key_block", + 1: "from", + 2: "to", + 3: "dest_proof", + 4: "config_proof", + 5: "signatures", } -// Decode decodes GetRawListBlockTransactionsOK from json. -func (s *GetRawListBlockTransactionsOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawBlockProofOKStepsItemLiteServerBlockLinkForward from json. +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawListBlockTransactionsOK to nil") + return errors.New("invalid: unable to decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForward to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "id": + case "to_key_block": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.ID.Decode(d); err != nil { + v, err := d.Bool() + s.ToKeyBlock = bool(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"id\"") + return errors.Wrap(err, "decode field \"to_key_block\"") } - case "req_count": + case "from": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int32() - s.ReqCount = int32(v) - if err != nil { + if err := s.From.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"req_count\"") + return errors.Wrap(err, "decode field \"from\"") } - case "incomplete": + case "to": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Bool() - s.Incomplete = bool(v) - if err != nil { + if err := s.To.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"incomplete\"") + return errors.Wrap(err, "decode field \"to\"") } - case "ids": + case "dest_proof": requiredBitSet[0] |= 1 << 3 if err := func() error { - s.Ids = make([]GetRawListBlockTransactionsOKIdsItem, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem GetRawListBlockTransactionsOKIdsItem - if err := elem.Decode(d); err != nil { - return err - } - s.Ids = append(s.Ids, elem) - return nil - }); err != nil { + v, err := d.Str() + s.DestProof = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ids\"") + return errors.Wrap(err, "decode field \"dest_proof\"") } - case "proof": + case "config_proof": requiredBitSet[0] |= 1 << 4 if err := func() error { v, err := d.Str() - s.Proof = string(v) + s.ConfigProof = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"proof\"") + return errors.Wrap(err, "decode field \"config_proof\"") + } + case "signatures": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + if err := s.Signatures.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"signatures\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawListBlockTransactionsOK") + return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForward") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00011111, + 0b00111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -19190,8 +20341,8 @@ func (s *GetRawListBlockTransactionsOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawListBlockTransactionsOK) { - name = jsonFieldsNameOfGetRawListBlockTransactionsOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForward) { + name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForward[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19212,120 +20363,113 @@ func (s *GetRawListBlockTransactionsOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawListBlockTransactionsOK) MarshalJSON() ([]byte, error) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawListBlockTransactionsOK) UnmarshalJSON(data []byte) error { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawListBlockTransactionsOKIdsItem) Encode(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawListBlockTransactionsOKIdsItem) encodeFields(e *jx.Encoder) { - { - e.FieldStart("mode") - e.Int32(s.Mode) - } +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) encodeFields(e *jx.Encoder) { { - if s.Account.Set { - e.FieldStart("account") - s.Account.Encode(e) - } + e.FieldStart("validator_set_hash") + e.Int64(s.ValidatorSetHash) } { - if s.Lt.Set { - e.FieldStart("lt") - s.Lt.Encode(e) - } + e.FieldStart("catchain_seqno") + e.Int32(s.CatchainSeqno) } { - if s.Hash.Set { - e.FieldStart("hash") - s.Hash.Encode(e) + e.FieldStart("signatures") + e.ArrStart() + for _, elem := range s.Signatures { + elem.Encode(e) } + e.ArrEnd() } } -var jsonFieldsNameOfGetRawListBlockTransactionsOKIdsItem = [4]string{ - 0: "mode", - 1: "account", - 2: "lt", - 3: "hash", +var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures = [3]string{ + 0: "validator_set_hash", + 1: "catchain_seqno", + 2: "signatures", } -// Decode decodes GetRawListBlockTransactionsOKIdsItem from json. -func (s *GetRawListBlockTransactionsOKIdsItem) Decode(d *jx.Decoder) error { +// Decode decodes GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures from json. +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawListBlockTransactionsOKIdsItem to nil") + return errors.New("invalid: unable to decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "mode": + case "validator_set_hash": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int32() - s.Mode = int32(v) + v, err := d.Int64() + s.ValidatorSetHash = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"mode\"") - } - case "account": - if err := func() error { - s.Account.Reset() - if err := s.Account.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"account\"") + return errors.Wrap(err, "decode field \"validator_set_hash\"") } - case "lt": + case "catchain_seqno": + requiredBitSet[0] |= 1 << 1 if err := func() error { - s.Lt.Reset() - if err := s.Lt.Decode(d); err != nil { + v, err := d.Int32() + s.CatchainSeqno = int32(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"lt\"") + return errors.Wrap(err, "decode field \"catchain_seqno\"") } - case "hash": + case "signatures": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Hash.Reset() - if err := s.Hash.Decode(d); err != nil { + s.Signatures = make([]GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem + if err := elem.Decode(d); err != nil { + return err + } + s.Signatures = append(s.Signatures, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"hash\"") + return errors.Wrap(err, "decode field \"signatures\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawListBlockTransactionsOKIdsItem") + return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -19337,8 +20481,8 @@ func (s *GetRawListBlockTransactionsOKIdsItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawListBlockTransactionsOKIdsItem) { - name = jsonFieldsNameOfGetRawListBlockTransactionsOKIdsItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) { + name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19359,184 +20503,86 @@ func (s *GetRawListBlockTransactionsOKIdsItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawListBlockTransactionsOKIdsItem) MarshalJSON() ([]byte, error) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawListBlockTransactionsOKIdsItem) UnmarshalJSON(data []byte) error { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawMasterchainInfoExtOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawMasterchainInfoExtOK) encodeFields(e *jx.Encoder) { - { - e.FieldStart("mode") - e.Int32(s.Mode) - } - { - e.FieldStart("version") - e.Int32(s.Version) - } +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("capabilities") - e.Int64(s.Capabilities) + e.FieldStart("node_id_short") + e.Str(s.NodeIDShort) } { - e.FieldStart("last") - s.Last.Encode(e) - } - { - e.FieldStart("last_utime") - e.Int32(s.LastUtime) - } - { - e.FieldStart("now") - e.Int32(s.Now) - } - { - e.FieldStart("state_root_hash") - e.Str(s.StateRootHash) - } - { - e.FieldStart("init") - s.Init.Encode(e) + e.FieldStart("signature") + e.Str(s.Signature) } } -var jsonFieldsNameOfGetRawMasterchainInfoExtOK = [8]string{ - 0: "mode", - 1: "version", - 2: "capabilities", - 3: "last", - 4: "last_utime", - 5: "now", - 6: "state_root_hash", - 7: "init", +var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem = [2]string{ + 0: "node_id_short", + 1: "signature", } -// Decode decodes GetRawMasterchainInfoExtOK from json. -func (s *GetRawMasterchainInfoExtOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem from json. +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawMasterchainInfoExtOK to nil") + return errors.New("invalid: unable to decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "mode": + case "node_id_short": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int32() - s.Mode = int32(v) + v, err := d.Str() + s.NodeIDShort = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"mode\"") + return errors.Wrap(err, "decode field \"node_id_short\"") } - case "version": + case "signature": requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Int32() - s.Version = int32(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"version\"") - } - case "capabilities": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Int64() - s.Capabilities = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"capabilities\"") - } - case "last": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - if err := s.Last.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"last\"") - } - case "last_utime": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Int32() - s.LastUtime = int32(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"last_utime\"") - } - case "now": - requiredBitSet[0] |= 1 << 5 - if err := func() error { - v, err := d.Int32() - s.Now = int32(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"now\"") - } - case "state_root_hash": - requiredBitSet[0] |= 1 << 6 if err := func() error { v, err := d.Str() - s.StateRootHash = string(v) + s.Signature = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"state_root_hash\"") - } - case "init": - requiredBitSet[0] |= 1 << 7 - if err := func() error { - if err := s.Init.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"init\"") + return errors.Wrap(err, "decode field \"signature\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawMasterchainInfoExtOK") + return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b11111111, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -19548,8 +20594,8 @@ func (s *GetRawMasterchainInfoExtOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawMasterchainInfoExtOK) { - name = jsonFieldsNameOfGetRawMasterchainInfoExtOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) { + name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19570,94 +20616,96 @@ func (s *GetRawMasterchainInfoExtOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawMasterchainInfoExtOK) MarshalJSON() ([]byte, error) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawMasterchainInfoExtOK) UnmarshalJSON(data []byte) error { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawMasterchainInfoOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockchainBlockHeaderOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawMasterchainInfoOK) encodeFields(e *jx.Encoder) { +func (s *GetRawBlockchainBlockHeaderOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("last") - s.Last.Encode(e) + e.FieldStart("id") + s.ID.Encode(e) } { - e.FieldStart("state_root_hash") - e.Str(s.StateRootHash) + e.FieldStart("mode") + e.Int32(s.Mode) } { - e.FieldStart("init") - s.Init.Encode(e) + e.FieldStart("header_proof") + e.Str(s.HeaderProof) } } -var jsonFieldsNameOfGetRawMasterchainInfoOK = [3]string{ - 0: "last", - 1: "state_root_hash", - 2: "init", +var jsonFieldsNameOfGetRawBlockchainBlockHeaderOK = [3]string{ + 0: "id", + 1: "mode", + 2: "header_proof", } -// Decode decodes GetRawMasterchainInfoOK from json. -func (s *GetRawMasterchainInfoOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawBlockchainBlockHeaderOK from json. +func (s *GetRawBlockchainBlockHeaderOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawMasterchainInfoOK to nil") + return errors.New("invalid: unable to decode GetRawBlockchainBlockHeaderOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "last": + case "id": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Last.Decode(d); err != nil { + if err := s.ID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"last\"") + return errors.Wrap(err, "decode field \"id\"") } - case "state_root_hash": + case "mode": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.StateRootHash = string(v) + v, err := d.Int32() + s.Mode = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"state_root_hash\"") + return errors.Wrap(err, "decode field \"mode\"") } - case "init": + case "header_proof": requiredBitSet[0] |= 1 << 2 if err := func() error { - if err := s.Init.Decode(d); err != nil { + v, err := d.Str() + s.HeaderProof = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"init\"") + return errors.Wrap(err, "decode field \"header_proof\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawMasterchainInfoOK") + return errors.Wrap(err, "decode GetRawBlockchainBlockHeaderOK") } // Validate required fields. var failures []validate.FieldError @@ -19674,8 +20722,8 @@ func (s *GetRawMasterchainInfoOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawMasterchainInfoOK) { - name = jsonFieldsNameOfGetRawMasterchainInfoOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawBlockchainBlockHeaderOK) { + name = jsonFieldsNameOfGetRawBlockchainBlockHeaderOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19696,89 +20744,79 @@ func (s *GetRawMasterchainInfoOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawMasterchainInfoOK) MarshalJSON() ([]byte, error) { +func (s *GetRawBlockchainBlockHeaderOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawMasterchainInfoOK) UnmarshalJSON(data []byte) error { +func (s *GetRawBlockchainBlockHeaderOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawShardBlockProofOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockchainBlockOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawShardBlockProofOK) encodeFields(e *jx.Encoder) { +func (s *GetRawBlockchainBlockOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("masterchain_id") - s.MasterchainID.Encode(e) + e.FieldStart("id") + s.ID.Encode(e) } { - e.FieldStart("links") - e.ArrStart() - for _, elem := range s.Links { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("data") + e.Str(s.Data) } } -var jsonFieldsNameOfGetRawShardBlockProofOK = [2]string{ - 0: "masterchain_id", - 1: "links", +var jsonFieldsNameOfGetRawBlockchainBlockOK = [2]string{ + 0: "id", + 1: "data", } -// Decode decodes GetRawShardBlockProofOK from json. -func (s *GetRawShardBlockProofOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawBlockchainBlockOK from json. +func (s *GetRawBlockchainBlockOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawShardBlockProofOK to nil") + return errors.New("invalid: unable to decode GetRawBlockchainBlockOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "masterchain_id": + case "id": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.MasterchainID.Decode(d); err != nil { + if err := s.ID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"masterchain_id\"") + return errors.Wrap(err, "decode field \"id\"") } - case "links": + case "data": requiredBitSet[0] |= 1 << 1 if err := func() error { - s.Links = make([]GetRawShardBlockProofOKLinksItem, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem GetRawShardBlockProofOKLinksItem - if err := elem.Decode(d); err != nil { - return err - } - s.Links = append(s.Links, elem) - return nil - }); err != nil { + v, err := d.Str() + s.Data = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"links\"") + return errors.Wrap(err, "decode field \"data\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawShardBlockProofOK") + return errors.Wrap(err, "decode GetRawBlockchainBlockOK") } // Validate required fields. var failures []validate.FieldError @@ -19795,8 +20833,8 @@ func (s *GetRawShardBlockProofOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawShardBlockProofOK) { - name = jsonFieldsNameOfGetRawShardBlockProofOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawBlockchainBlockOK) { + name = jsonFieldsNameOfGetRawBlockchainBlockOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19817,46 +20855,56 @@ func (s *GetRawShardBlockProofOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawShardBlockProofOK) MarshalJSON() ([]byte, error) { +func (s *GetRawBlockchainBlockOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawShardBlockProofOK) UnmarshalJSON(data []byte) error { +func (s *GetRawBlockchainBlockOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawShardBlockProofOKLinksItem) Encode(e *jx.Encoder) { +func (s *GetRawBlockchainBlockStateOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawShardBlockProofOKLinksItem) encodeFields(e *jx.Encoder) { +func (s *GetRawBlockchainBlockStateOK) encodeFields(e *jx.Encoder) { { e.FieldStart("id") s.ID.Encode(e) } { - e.FieldStart("proof") - e.Str(s.Proof) + e.FieldStart("root_hash") + e.Str(s.RootHash) + } + { + e.FieldStart("file_hash") + e.Str(s.FileHash) + } + { + e.FieldStart("data") + e.Str(s.Data) } } -var jsonFieldsNameOfGetRawShardBlockProofOKLinksItem = [2]string{ +var jsonFieldsNameOfGetRawBlockchainBlockStateOK = [4]string{ 0: "id", - 1: "proof", + 1: "root_hash", + 2: "file_hash", + 3: "data", } -// Decode decodes GetRawShardBlockProofOKLinksItem from json. -func (s *GetRawShardBlockProofOKLinksItem) Decode(d *jx.Decoder) error { +// Decode decodes GetRawBlockchainBlockStateOK from json. +func (s *GetRawBlockchainBlockStateOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawShardBlockProofOKLinksItem to nil") + return errors.New("invalid: unable to decode GetRawBlockchainBlockStateOK to nil") } var requiredBitSet [1]uint8 @@ -19872,29 +20920,53 @@ func (s *GetRawShardBlockProofOKLinksItem) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"id\"") } - case "proof": + case "root_hash": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.Proof = string(v) + s.RootHash = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"proof\"") + return errors.Wrap(err, "decode field \"root_hash\"") + } + case "file_hash": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.FileHash = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"file_hash\"") + } + case "data": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.Data = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"data\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawShardBlockProofOKLinksItem") + return errors.Wrap(err, "decode GetRawBlockchainBlockStateOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000011, + 0b00001111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -19906,8 +20978,8 @@ func (s *GetRawShardBlockProofOKLinksItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawShardBlockProofOKLinksItem) { - name = jsonFieldsNameOfGetRawShardBlockProofOKLinksItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawBlockchainBlockStateOK) { + name = jsonFieldsNameOfGetRawBlockchainBlockStateOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19928,111 +21000,113 @@ func (s *GetRawShardBlockProofOKLinksItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawShardBlockProofOKLinksItem) MarshalJSON() ([]byte, error) { +func (s *GetRawBlockchainBlockStateOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawShardBlockProofOKLinksItem) UnmarshalJSON(data []byte) error { +func (s *GetRawBlockchainBlockStateOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawShardInfoOK) Encode(e *jx.Encoder) { +func (s *GetRawConfigOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawShardInfoOK) encodeFields(e *jx.Encoder) { +func (s *GetRawConfigOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("id") - s.ID.Encode(e) + e.FieldStart("mode") + e.Int32(s.Mode) } { - e.FieldStart("shardblk") - s.Shardblk.Encode(e) + e.FieldStart("id") + s.ID.Encode(e) } { - e.FieldStart("shard_proof") - e.Str(s.ShardProof) + e.FieldStart("state_proof") + e.Str(s.StateProof) } { - e.FieldStart("shard_descr") - e.Str(s.ShardDescr) + e.FieldStart("config_proof") + e.Str(s.ConfigProof) } } -var jsonFieldsNameOfGetRawShardInfoOK = [4]string{ - 0: "id", - 1: "shardblk", - 2: "shard_proof", - 3: "shard_descr", +var jsonFieldsNameOfGetRawConfigOK = [4]string{ + 0: "mode", + 1: "id", + 2: "state_proof", + 3: "config_proof", } -// Decode decodes GetRawShardInfoOK from json. -func (s *GetRawShardInfoOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawConfigOK from json. +func (s *GetRawConfigOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawShardInfoOK to nil") + return errors.New("invalid: unable to decode GetRawConfigOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "id": + case "mode": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.ID.Decode(d); err != nil { + v, err := d.Int32() + s.Mode = int32(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"id\"") + return errors.Wrap(err, "decode field \"mode\"") } - case "shardblk": + case "id": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Shardblk.Decode(d); err != nil { + if err := s.ID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"shardblk\"") + return errors.Wrap(err, "decode field \"id\"") } - case "shard_proof": + case "state_proof": requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.ShardProof = string(v) + s.StateProof = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"shard_proof\"") + return errors.Wrap(err, "decode field \"state_proof\"") } - case "shard_descr": + case "config_proof": requiredBitSet[0] |= 1 << 3 if err := func() error { v, err := d.Str() - s.ShardDescr = string(v) + s.ConfigProof = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"shard_descr\"") + return errors.Wrap(err, "decode field \"config_proof\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawShardInfoOK") + return errors.Wrap(err, "decode GetRawConfigOK") } // Validate required fields. var failures []validate.FieldError @@ -20049,8 +21123,8 @@ func (s *GetRawShardInfoOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawShardInfoOK) { - name = jsonFieldsNameOfGetRawShardInfoOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawConfigOK) { + name = jsonFieldsNameOfGetRawConfigOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20071,69 +21145,145 @@ func (s *GetRawShardInfoOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawShardInfoOK) MarshalJSON() ([]byte, error) { +func (s *GetRawConfigOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawShardInfoOK) UnmarshalJSON(data []byte) error { +func (s *GetRawConfigOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawTimeOK) Encode(e *jx.Encoder) { +func (s *GetRawListBlockTransactionsOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawTimeOK) encodeFields(e *jx.Encoder) { +func (s *GetRawListBlockTransactionsOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("time") - e.Int32(s.Time) + e.FieldStart("id") + s.ID.Encode(e) + } + { + e.FieldStart("req_count") + e.Int32(s.ReqCount) + } + { + e.FieldStart("incomplete") + e.Bool(s.Incomplete) + } + { + e.FieldStart("ids") + e.ArrStart() + for _, elem := range s.Ids { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("proof") + e.Str(s.Proof) } } -var jsonFieldsNameOfGetRawTimeOK = [1]string{ - 0: "time", +var jsonFieldsNameOfGetRawListBlockTransactionsOK = [5]string{ + 0: "id", + 1: "req_count", + 2: "incomplete", + 3: "ids", + 4: "proof", } -// Decode decodes GetRawTimeOK from json. -func (s *GetRawTimeOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawListBlockTransactionsOK from json. +func (s *GetRawListBlockTransactionsOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawTimeOK to nil") + return errors.New("invalid: unable to decode GetRawListBlockTransactionsOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "time": + case "id": requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.ID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "req_count": + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Int32() - s.Time = int32(v) + s.ReqCount = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"time\"") + return errors.Wrap(err, "decode field \"req_count\"") + } + case "incomplete": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Bool() + s.Incomplete = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"incomplete\"") + } + case "ids": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + s.Ids = make([]GetRawListBlockTransactionsOKIdsItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem GetRawListBlockTransactionsOKIdsItem + if err := elem.Decode(d); err != nil { + return err + } + s.Ids = append(s.Ids, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ids\"") + } + case "proof": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Str() + s.Proof = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"proof\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawTimeOK") + return errors.Wrap(err, "decode GetRawListBlockTransactionsOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00011111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -20145,8 +21295,8 @@ func (s *GetRawTimeOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawTimeOK) { - name = jsonFieldsNameOfGetRawTimeOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawListBlockTransactionsOK) { + name = jsonFieldsNameOfGetRawListBlockTransactionsOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20167,96 +21317,120 @@ func (s *GetRawTimeOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawTimeOK) MarshalJSON() ([]byte, error) { +func (s *GetRawListBlockTransactionsOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawTimeOK) UnmarshalJSON(data []byte) error { +func (s *GetRawListBlockTransactionsOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetRawTransactionsOK) Encode(e *jx.Encoder) { +func (s *GetRawListBlockTransactionsOKIdsItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawTransactionsOK) encodeFields(e *jx.Encoder) { +func (s *GetRawListBlockTransactionsOKIdsItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("ids") - e.ArrStart() - for _, elem := range s.Ids { - elem.Encode(e) + e.FieldStart("mode") + e.Int32(s.Mode) + } + { + if s.Account.Set { + e.FieldStart("account") + s.Account.Encode(e) } - e.ArrEnd() } { - e.FieldStart("transactions") - e.Str(s.Transactions) + if s.Lt.Set { + e.FieldStart("lt") + s.Lt.Encode(e) + } + } + { + if s.Hash.Set { + e.FieldStart("hash") + s.Hash.Encode(e) + } } } -var jsonFieldsNameOfGetRawTransactionsOK = [2]string{ - 0: "ids", - 1: "transactions", +var jsonFieldsNameOfGetRawListBlockTransactionsOKIdsItem = [4]string{ + 0: "mode", + 1: "account", + 2: "lt", + 3: "hash", } -// Decode decodes GetRawTransactionsOK from json. -func (s *GetRawTransactionsOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawListBlockTransactionsOKIdsItem from json. +func (s *GetRawListBlockTransactionsOKIdsItem) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetRawTransactionsOK to nil") + return errors.New("invalid: unable to decode GetRawListBlockTransactionsOKIdsItem to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "ids": + case "mode": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Ids = make([]BlockRaw, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem BlockRaw - if err := elem.Decode(d); err != nil { - return err - } - s.Ids = append(s.Ids, elem) - return nil - }); err != nil { + v, err := d.Int32() + s.Mode = int32(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ids\"") + return errors.Wrap(err, "decode field \"mode\"") } - case "transactions": - requiredBitSet[0] |= 1 << 1 + case "account": if err := func() error { - v, err := d.Str() - s.Transactions = string(v) - if err != nil { + s.Account.Reset() + if err := s.Account.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"transactions\"") + return errors.Wrap(err, "decode field \"account\"") + } + case "lt": + if err := func() error { + s.Lt.Reset() + if err := s.Lt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"lt\"") + } + case "hash": + if err := func() error { + s.Hash.Reset() + if err := s.Hash.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"hash\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawTransactionsOK") + return errors.Wrap(err, "decode GetRawListBlockTransactionsOKIdsItem") } // 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. @@ -20268,8 +21442,8 @@ func (s *GetRawTransactionsOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawTransactionsOK) { - name = jsonFieldsNameOfGetRawTransactionsOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawListBlockTransactionsOKIdsItem) { + name = jsonFieldsNameOfGetRawListBlockTransactionsOKIdsItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20290,79 +21464,184 @@ func (s *GetRawTransactionsOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawTransactionsOK) MarshalJSON() ([]byte, error) { +func (s *GetRawListBlockTransactionsOKIdsItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRawTransactionsOK) UnmarshalJSON(data []byte) error { +func (s *GetRawListBlockTransactionsOKIdsItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetStakingPoolHistoryOK) Encode(e *jx.Encoder) { +func (s *GetRawMasterchainInfoExtOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetStakingPoolHistoryOK) encodeFields(e *jx.Encoder) { +func (s *GetRawMasterchainInfoExtOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("apy") - e.ArrStart() - for _, elem := range s.Apy { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("mode") + e.Int32(s.Mode) + } + { + e.FieldStart("version") + e.Int32(s.Version) + } + { + e.FieldStart("capabilities") + e.Int64(s.Capabilities) + } + { + e.FieldStart("last") + s.Last.Encode(e) + } + { + e.FieldStart("last_utime") + e.Int32(s.LastUtime) + } + { + e.FieldStart("now") + e.Int32(s.Now) + } + { + e.FieldStart("state_root_hash") + e.Str(s.StateRootHash) + } + { + e.FieldStart("init") + s.Init.Encode(e) } } -var jsonFieldsNameOfGetStakingPoolHistoryOK = [1]string{ - 0: "apy", +var jsonFieldsNameOfGetRawMasterchainInfoExtOK = [8]string{ + 0: "mode", + 1: "version", + 2: "capabilities", + 3: "last", + 4: "last_utime", + 5: "now", + 6: "state_root_hash", + 7: "init", } -// Decode decodes GetStakingPoolHistoryOK from json. -func (s *GetStakingPoolHistoryOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawMasterchainInfoExtOK from json. +func (s *GetRawMasterchainInfoExtOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetStakingPoolHistoryOK to nil") + return errors.New("invalid: unable to decode GetRawMasterchainInfoExtOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "apy": + case "mode": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Apy = make([]ApyHistory, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem ApyHistory - if err := elem.Decode(d); err != nil { - return err - } - s.Apy = append(s.Apy, elem) - return nil - }); err != nil { + v, err := d.Int32() + s.Mode = int32(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"apy\"") + return errors.Wrap(err, "decode field \"mode\"") + } + case "version": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int32() + s.Version = int32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"version\"") + } + case "capabilities": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int64() + s.Capabilities = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"capabilities\"") + } + case "last": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + if err := s.Last.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"last\"") + } + case "last_utime": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int32() + s.LastUtime = int32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"last_utime\"") + } + case "now": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Int32() + s.Now = int32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"now\"") + } + case "state_root_hash": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + v, err := d.Str() + s.StateRootHash = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"state_root_hash\"") + } + case "init": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + if err := s.Init.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"init\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetStakingPoolHistoryOK") + return errors.Wrap(err, "decode GetRawMasterchainInfoExtOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b11111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -20374,8 +21653,8 @@ func (s *GetStakingPoolHistoryOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetStakingPoolHistoryOK) { - name = jsonFieldsNameOfGetStakingPoolHistoryOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawMasterchainInfoExtOK) { + name = jsonFieldsNameOfGetRawMasterchainInfoExtOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20396,82 +21675,99 @@ func (s *GetStakingPoolHistoryOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetStakingPoolHistoryOK) MarshalJSON() ([]byte, error) { +func (s *GetRawMasterchainInfoExtOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetStakingPoolHistoryOK) UnmarshalJSON(data []byte) error { +func (s *GetRawMasterchainInfoExtOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetStakingPoolInfoOK) Encode(e *jx.Encoder) { +func (s *GetRawMasterchainInfoOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetStakingPoolInfoOK) encodeFields(e *jx.Encoder) { +func (s *GetRawMasterchainInfoOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("implementation") - s.Implementation.Encode(e) + e.FieldStart("last") + s.Last.Encode(e) } { - e.FieldStart("pool") - s.Pool.Encode(e) + e.FieldStart("state_root_hash") + e.Str(s.StateRootHash) + } + { + e.FieldStart("init") + s.Init.Encode(e) } } -var jsonFieldsNameOfGetStakingPoolInfoOK = [2]string{ - 0: "implementation", - 1: "pool", +var jsonFieldsNameOfGetRawMasterchainInfoOK = [3]string{ + 0: "last", + 1: "state_root_hash", + 2: "init", } -// Decode decodes GetStakingPoolInfoOK from json. -func (s *GetStakingPoolInfoOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawMasterchainInfoOK from json. +func (s *GetRawMasterchainInfoOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetStakingPoolInfoOK to nil") + return errors.New("invalid: unable to decode GetRawMasterchainInfoOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "implementation": + case "last": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Implementation.Decode(d); err != nil { + if err := s.Last.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"implementation\"") + return errors.Wrap(err, "decode field \"last\"") } - case "pool": + case "state_root_hash": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Pool.Decode(d); err != nil { + v, err := d.Str() + s.StateRootHash = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"pool\"") + return errors.Wrap(err, "decode field \"state_root_hash\"") + } + case "init": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.Init.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"init\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetStakingPoolInfoOK") + return errors.Wrap(err, "decode GetRawMasterchainInfoOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000011, + 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -20483,8 +21779,8 @@ func (s *GetStakingPoolInfoOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetStakingPoolInfoOK) { - name = jsonFieldsNameOfGetStakingPoolInfoOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawMasterchainInfoOK) { + name = jsonFieldsNameOfGetRawMasterchainInfoOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20505,89 +21801,89 @@ func (s *GetStakingPoolInfoOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetStakingPoolInfoOK) MarshalJSON() ([]byte, error) { +func (s *GetRawMasterchainInfoOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetStakingPoolInfoOK) UnmarshalJSON(data []byte) error { +func (s *GetRawMasterchainInfoOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetStakingPoolsOK) Encode(e *jx.Encoder) { +func (s *GetRawShardBlockProofOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetStakingPoolsOK) encodeFields(e *jx.Encoder) { +func (s *GetRawShardBlockProofOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("pools") + e.FieldStart("masterchain_id") + s.MasterchainID.Encode(e) + } + { + e.FieldStart("links") e.ArrStart() - for _, elem := range s.Pools { + for _, elem := range s.Links { elem.Encode(e) } e.ArrEnd() } - { - e.FieldStart("implementations") - s.Implementations.Encode(e) - } } -var jsonFieldsNameOfGetStakingPoolsOK = [2]string{ - 0: "pools", - 1: "implementations", +var jsonFieldsNameOfGetRawShardBlockProofOK = [2]string{ + 0: "masterchain_id", + 1: "links", } -// Decode decodes GetStakingPoolsOK from json. -func (s *GetStakingPoolsOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawShardBlockProofOK from json. +func (s *GetRawShardBlockProofOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetStakingPoolsOK to nil") + return errors.New("invalid: unable to decode GetRawShardBlockProofOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "pools": + case "masterchain_id": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Pools = make([]PoolInfo, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem PoolInfo - if err := elem.Decode(d); err != nil { - return err - } - s.Pools = append(s.Pools, elem) - return nil - }); err != nil { + if err := s.MasterchainID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"pools\"") + return errors.Wrap(err, "decode field \"masterchain_id\"") } - case "implementations": + case "links": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Implementations.Decode(d); err != nil { + s.Links = make([]GetRawShardBlockProofOKLinksItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem GetRawShardBlockProofOKLinksItem + if err := elem.Decode(d); err != nil { + return err + } + s.Links = append(s.Links, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"implementations\"") + return errors.Wrap(err, "decode field \"links\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetStakingPoolsOK") + return errors.Wrap(err, "decode GetRawShardBlockProofOK") } // Validate required fields. var failures []validate.FieldError @@ -20604,8 +21900,8 @@ func (s *GetStakingPoolsOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetStakingPoolsOK) { - name = jsonFieldsNameOfGetStakingPoolsOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawShardBlockProofOK) { + name = jsonFieldsNameOfGetRawShardBlockProofOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20626,133 +21922,84 @@ func (s *GetStakingPoolsOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetStakingPoolsOK) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetStakingPoolsOK) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s GetStakingPoolsOKImplementations) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields implements json.Marshaler. -func (s GetStakingPoolsOKImplementations) encodeFields(e *jx.Encoder) { - for k, elem := range s { - e.FieldStart(k) - - elem.Encode(e) - } -} - -// Decode decodes GetStakingPoolsOKImplementations from json. -func (s *GetStakingPoolsOKImplementations) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode GetStakingPoolsOKImplementations to nil") - } - m := s.init() - if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - var elem PoolImplementation - if err := func() error { - if err := elem.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrapf(err, "decode field %q", k) - } - m[string(k)] = elem - return nil - }); err != nil { - return errors.Wrap(err, "decode GetStakingPoolsOKImplementations") - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s GetStakingPoolsOKImplementations) MarshalJSON() ([]byte, error) { +func (s *GetRawShardBlockProofOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetStakingPoolsOKImplementations) UnmarshalJSON(data []byte) error { +func (s *GetRawShardBlockProofOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetStorageProvidersOK) Encode(e *jx.Encoder) { +func (s *GetRawShardBlockProofOKLinksItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetStorageProvidersOK) encodeFields(e *jx.Encoder) { +func (s *GetRawShardBlockProofOKLinksItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("providers") - e.ArrStart() - for _, elem := range s.Providers { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("id") + s.ID.Encode(e) + } + { + e.FieldStart("proof") + e.Str(s.Proof) } } -var jsonFieldsNameOfGetStorageProvidersOK = [1]string{ - 0: "providers", +var jsonFieldsNameOfGetRawShardBlockProofOKLinksItem = [2]string{ + 0: "id", + 1: "proof", } -// Decode decodes GetStorageProvidersOK from json. -func (s *GetStorageProvidersOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawShardBlockProofOKLinksItem from json. +func (s *GetRawShardBlockProofOKLinksItem) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetStorageProvidersOK to nil") + return errors.New("invalid: unable to decode GetRawShardBlockProofOKLinksItem to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "providers": + case "id": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Providers = make([]StorageProvider, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem StorageProvider - if err := elem.Decode(d); err != nil { - return err - } - s.Providers = append(s.Providers, elem) - return nil - }); err != nil { + if err := s.ID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"providers\"") + return errors.Wrap(err, "decode field \"id\"") + } + case "proof": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Proof = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"proof\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetStorageProvidersOK") + return errors.Wrap(err, "decode GetRawShardBlockProofOKLinksItem") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -20764,8 +22011,8 @@ func (s *GetStorageProvidersOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetStorageProvidersOK) { - name = jsonFieldsNameOfGetStorageProvidersOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawShardBlockProofOKLinksItem) { + name = jsonFieldsNameOfGetRawShardBlockProofOKLinksItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20786,69 +22033,116 @@ func (s *GetStorageProvidersOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetStorageProvidersOK) MarshalJSON() ([]byte, error) { +func (s *GetRawShardBlockProofOKLinksItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetStorageProvidersOK) UnmarshalJSON(data []byte) error { +func (s *GetRawShardBlockProofOKLinksItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetTonConnectPayloadOK) Encode(e *jx.Encoder) { +func (s *GetRawShardInfoOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetTonConnectPayloadOK) encodeFields(e *jx.Encoder) { +func (s *GetRawShardInfoOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("payload") - e.Str(s.Payload) + e.FieldStart("id") + s.ID.Encode(e) + } + { + e.FieldStart("shardblk") + s.Shardblk.Encode(e) + } + { + e.FieldStart("shard_proof") + e.Str(s.ShardProof) + } + { + e.FieldStart("shard_descr") + e.Str(s.ShardDescr) } } -var jsonFieldsNameOfGetTonConnectPayloadOK = [1]string{ - 0: "payload", +var jsonFieldsNameOfGetRawShardInfoOK = [4]string{ + 0: "id", + 1: "shardblk", + 2: "shard_proof", + 3: "shard_descr", } -// Decode decodes GetTonConnectPayloadOK from json. -func (s *GetTonConnectPayloadOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawShardInfoOK from json. +func (s *GetRawShardInfoOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetTonConnectPayloadOK to nil") + return errors.New("invalid: unable to decode GetRawShardInfoOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "payload": + case "id": requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.ID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "shardblk": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Shardblk.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"shardblk\"") + } + case "shard_proof": + requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.Payload = string(v) + s.ShardProof = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"payload\"") + return errors.Wrap(err, "decode field \"shard_proof\"") + } + case "shard_descr": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.ShardDescr = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"shard_descr\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetTonConnectPayloadOK") + return errors.Wrap(err, "decode GetRawShardInfoOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00001111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -20860,8 +22154,8 @@ func (s *GetTonConnectPayloadOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetTonConnectPayloadOK) { - name = jsonFieldsNameOfGetTonConnectPayloadOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawShardInfoOK) { + name = jsonFieldsNameOfGetRawShardInfoOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20882,64 +22176,64 @@ func (s *GetTonConnectPayloadOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetTonConnectPayloadOK) MarshalJSON() ([]byte, error) { +func (s *GetRawShardInfoOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetTonConnectPayloadOK) UnmarshalJSON(data []byte) error { +func (s *GetRawShardInfoOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GetWalletBackupOK) Encode(e *jx.Encoder) { +func (s *GetRawTimeOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetWalletBackupOK) encodeFields(e *jx.Encoder) { +func (s *GetRawTimeOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("dump") - e.Str(s.Dump) + e.FieldStart("time") + e.Int32(s.Time) } } -var jsonFieldsNameOfGetWalletBackupOK = [1]string{ - 0: "dump", +var jsonFieldsNameOfGetRawTimeOK = [1]string{ + 0: "time", } -// Decode decodes GetWalletBackupOK from json. -func (s *GetWalletBackupOK) Decode(d *jx.Decoder) error { +// Decode decodes GetRawTimeOK from json. +func (s *GetRawTimeOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode GetWalletBackupOK to nil") + return errors.New("invalid: unable to decode GetRawTimeOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "dump": + case "time": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Dump = string(v) + v, err := d.Int32() + s.Time = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"dump\"") + return errors.Wrap(err, "decode field \"time\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetWalletBackupOK") + return errors.Wrap(err, "decode GetRawTimeOK") } // Validate required fields. var failures []validate.FieldError @@ -20956,8 +22250,8 @@ func (s *GetWalletBackupOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetWalletBackupOK) { - name = jsonFieldsNameOfGetWalletBackupOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawTimeOK) { + name = jsonFieldsNameOfGetRawTimeOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20978,81 +22272,91 @@ func (s *GetWalletBackupOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetWalletBackupOK) MarshalJSON() ([]byte, error) { +func (s *GetRawTimeOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetWalletBackupOK) UnmarshalJSON(data []byte) error { +func (s *GetRawTimeOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ImagePreview) Encode(e *jx.Encoder) { +func (s *GetRawTransactionsOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ImagePreview) encodeFields(e *jx.Encoder) { +func (s *GetRawTransactionsOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("resolution") - e.Str(s.Resolution) + e.FieldStart("ids") + e.ArrStart() + for _, elem := range s.Ids { + elem.Encode(e) + } + e.ArrEnd() } { - e.FieldStart("url") - e.Str(s.URL) + e.FieldStart("transactions") + e.Str(s.Transactions) } } -var jsonFieldsNameOfImagePreview = [2]string{ - 0: "resolution", - 1: "url", +var jsonFieldsNameOfGetRawTransactionsOK = [2]string{ + 0: "ids", + 1: "transactions", } -// Decode decodes ImagePreview from json. -func (s *ImagePreview) Decode(d *jx.Decoder) error { +// Decode decodes GetRawTransactionsOK from json. +func (s *GetRawTransactionsOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ImagePreview to nil") + return errors.New("invalid: unable to decode GetRawTransactionsOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "resolution": + case "ids": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Resolution = string(v) - if err != nil { + s.Ids = make([]BlockRaw, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem BlockRaw + if err := elem.Decode(d); err != nil { + return err + } + s.Ids = append(s.Ids, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"resolution\"") + return errors.Wrap(err, "decode field \"ids\"") } - case "url": + case "transactions": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.URL = string(v) + s.Transactions = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"url\"") + return errors.Wrap(err, "decode field \"transactions\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ImagePreview") + return errors.Wrap(err, "decode GetRawTransactionsOK") } // Validate required fields. var failures []validate.FieldError @@ -21069,8 +22373,8 @@ func (s *ImagePreview) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfImagePreview) { - name = jsonFieldsNameOfImagePreview[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawTransactionsOK) { + name = jsonFieldsNameOfGetRawTransactionsOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21091,103 +22395,79 @@ func (s *ImagePreview) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ImagePreview) MarshalJSON() ([]byte, error) { +func (s *GetRawTransactionsOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ImagePreview) UnmarshalJSON(data []byte) error { +func (s *GetRawTransactionsOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *InitStateRaw) Encode(e *jx.Encoder) { +func (s *GetStakingPoolHistoryOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *InitStateRaw) encodeFields(e *jx.Encoder) { - { - e.FieldStart("workchain") - e.Int32(s.Workchain) - } - { - e.FieldStart("root_hash") - e.Str(s.RootHash) - } +func (s *GetStakingPoolHistoryOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("file_hash") - e.Str(s.FileHash) + e.FieldStart("apy") + e.ArrStart() + for _, elem := range s.Apy { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfInitStateRaw = [3]string{ - 0: "workchain", - 1: "root_hash", - 2: "file_hash", +var jsonFieldsNameOfGetStakingPoolHistoryOK = [1]string{ + 0: "apy", } -// Decode decodes InitStateRaw from json. -func (s *InitStateRaw) Decode(d *jx.Decoder) error { +// Decode decodes GetStakingPoolHistoryOK from json. +func (s *GetStakingPoolHistoryOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode InitStateRaw to nil") + return errors.New("invalid: unable to decode GetStakingPoolHistoryOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "workchain": + case "apy": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int32() - s.Workchain = int32(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"workchain\"") - } - case "root_hash": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Str() - s.RootHash = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"root_hash\"") - } - case "file_hash": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Str() - s.FileHash = string(v) - if err != nil { + s.Apy = make([]ApyHistory, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ApyHistory + if err := elem.Decode(d); err != nil { + return err + } + s.Apy = append(s.Apy, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"file_hash\"") + return errors.Wrap(err, "decode field \"apy\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode InitStateRaw") + return errors.Wrap(err, "decode GetStakingPoolHistoryOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -21199,8 +22479,8 @@ func (s *InitStateRaw) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfInitStateRaw) { - name = jsonFieldsNameOfInitStateRaw[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetStakingPoolHistoryOK) { + name = jsonFieldsNameOfGetStakingPoolHistoryOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21221,118 +22501,203 @@ func (s *InitStateRaw) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *InitStateRaw) MarshalJSON() ([]byte, error) { +func (s *GetStakingPoolHistoryOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *InitStateRaw) UnmarshalJSON(data []byte) error { +func (s *GetStakingPoolHistoryOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *InscriptionBalance) Encode(e *jx.Encoder) { +func (s *GetStakingPoolInfoOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *InscriptionBalance) encodeFields(e *jx.Encoder) { - { - e.FieldStart("type") - s.Type.Encode(e) - } - { - e.FieldStart("ticker") - e.Str(s.Ticker) - } +func (s *GetStakingPoolInfoOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("balance") - e.Str(s.Balance) + e.FieldStart("implementation") + s.Implementation.Encode(e) } { - e.FieldStart("decimals") - e.Int(s.Decimals) + e.FieldStart("pool") + s.Pool.Encode(e) } } -var jsonFieldsNameOfInscriptionBalance = [4]string{ - 0: "type", - 1: "ticker", - 2: "balance", - 3: "decimals", +var jsonFieldsNameOfGetStakingPoolInfoOK = [2]string{ + 0: "implementation", + 1: "pool", } -// Decode decodes InscriptionBalance from json. -func (s *InscriptionBalance) Decode(d *jx.Decoder) error { +// Decode decodes GetStakingPoolInfoOK from json. +func (s *GetStakingPoolInfoOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode InscriptionBalance to nil") + return errors.New("invalid: unable to decode GetStakingPoolInfoOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "type": + case "implementation": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Type.Decode(d); err != nil { + if err := s.Implementation.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"type\"") + return errors.Wrap(err, "decode field \"implementation\"") } - case "ticker": + case "pool": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.Ticker = string(v) - if err != nil { + if err := s.Pool.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ticker\"") + return errors.Wrap(err, "decode field \"pool\"") } - case "balance": - requiredBitSet[0] |= 1 << 2 + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode GetStakingPoolInfoOK") + } + // 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(jsonFieldsNameOfGetStakingPoolInfoOK) { + name = jsonFieldsNameOfGetStakingPoolInfoOK[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 *GetStakingPoolInfoOK) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GetStakingPoolInfoOK) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *GetStakingPoolsOK) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *GetStakingPoolsOK) encodeFields(e *jx.Encoder) { + { + e.FieldStart("pools") + e.ArrStart() + for _, elem := range s.Pools { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("implementations") + s.Implementations.Encode(e) + } +} + +var jsonFieldsNameOfGetStakingPoolsOK = [2]string{ + 0: "pools", + 1: "implementations", +} + +// Decode decodes GetStakingPoolsOK from json. +func (s *GetStakingPoolsOK) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GetStakingPoolsOK to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "pools": + requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Balance = string(v) - if err != nil { + s.Pools = make([]PoolInfo, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem PoolInfo + if err := elem.Decode(d); err != nil { + return err + } + s.Pools = append(s.Pools, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"balance\"") + return errors.Wrap(err, "decode field \"pools\"") } - case "decimals": - requiredBitSet[0] |= 1 << 3 + case "implementations": + requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int() - s.Decimals = int(v) - if err != nil { + if err := s.Implementations.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"decimals\"") + return errors.Wrap(err, "decode field \"implementations\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode InscriptionBalance") + return errors.Wrap(err, "decode GetStakingPoolsOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001111, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -21344,8 +22709,8 @@ func (s *InscriptionBalance) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfInscriptionBalance) { - name = jsonFieldsNameOfInscriptionBalance[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetStakingPoolsOK) { + name = jsonFieldsNameOfGetStakingPoolsOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21366,114 +22731,128 @@ func (s *InscriptionBalance) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *InscriptionBalance) MarshalJSON() ([]byte, error) { +func (s *GetStakingPoolsOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *InscriptionBalance) UnmarshalJSON(data []byte) error { +func (s *GetStakingPoolsOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode encodes InscriptionBalanceType as json. -func (s InscriptionBalanceType) Encode(e *jx.Encoder) { - e.Str(string(s)) +// Encode implements json.Marshaler. +func (s GetStakingPoolsOKImplementations) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() } -// Decode decodes InscriptionBalanceType from json. -func (s *InscriptionBalanceType) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode InscriptionBalanceType to nil") +// encodeFields implements json.Marshaler. +func (s GetStakingPoolsOKImplementations) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + elem.Encode(e) } - v, err := d.StrBytes() - if err != nil { - return err +} + +// Decode decodes GetStakingPoolsOKImplementations from json. +func (s *GetStakingPoolsOKImplementations) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GetStakingPoolsOKImplementations to nil") } - // Try to use constant string. - switch InscriptionBalanceType(v) { - case InscriptionBalanceTypeTon20: - *s = InscriptionBalanceTypeTon20 - case InscriptionBalanceTypeGram20: - *s = InscriptionBalanceTypeGram20 - default: - *s = InscriptionBalanceType(v) + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem PoolImplementation + if err := func() error { + if err := elem.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode GetStakingPoolsOKImplementations") } return nil } // MarshalJSON implements stdjson.Marshaler. -func (s InscriptionBalanceType) MarshalJSON() ([]byte, error) { +func (s GetStakingPoolsOKImplementations) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *InscriptionBalanceType) UnmarshalJSON(data []byte) error { +func (s *GetStakingPoolsOKImplementations) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *InscriptionBalances) Encode(e *jx.Encoder) { +func (s *GetStorageProvidersOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *InscriptionBalances) encodeFields(e *jx.Encoder) { +func (s *GetStorageProvidersOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("inscriptions") + e.FieldStart("providers") e.ArrStart() - for _, elem := range s.Inscriptions { + for _, elem := range s.Providers { elem.Encode(e) } e.ArrEnd() } } -var jsonFieldsNameOfInscriptionBalances = [1]string{ - 0: "inscriptions", +var jsonFieldsNameOfGetStorageProvidersOK = [1]string{ + 0: "providers", } -// Decode decodes InscriptionBalances from json. -func (s *InscriptionBalances) Decode(d *jx.Decoder) error { +// Decode decodes GetStorageProvidersOK from json. +func (s *GetStorageProvidersOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode InscriptionBalances to nil") + return errors.New("invalid: unable to decode GetStorageProvidersOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "inscriptions": + case "providers": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Inscriptions = make([]InscriptionBalance, 0) + s.Providers = make([]StorageProvider, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem InscriptionBalance + var elem StorageProvider if err := elem.Decode(d); err != nil { return err } - s.Inscriptions = append(s.Inscriptions, elem) + s.Providers = append(s.Providers, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"inscriptions\"") + return errors.Wrap(err, "decode field \"providers\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode InscriptionBalances") + return errors.Wrap(err, "decode GetStorageProvidersOK") } // Validate required fields. var failures []validate.FieldError @@ -21490,8 +22869,8 @@ func (s *InscriptionBalances) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfInscriptionBalances) { - name = jsonFieldsNameOfInscriptionBalances[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetStorageProvidersOK) { + name = jsonFieldsNameOfGetStorageProvidersOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21512,133 +22891,69 @@ func (s *InscriptionBalances) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *InscriptionBalances) MarshalJSON() ([]byte, error) { +func (s *GetStorageProvidersOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *InscriptionBalances) UnmarshalJSON(data []byte) error { +func (s *GetStorageProvidersOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *InscriptionMintAction) Encode(e *jx.Encoder) { +func (s *GetTonConnectPayloadOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *InscriptionMintAction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("recipient") - s.Recipient.Encode(e) - } - { - e.FieldStart("amount") - e.Str(s.Amount) - } - { - e.FieldStart("type") - s.Type.Encode(e) - } - { - e.FieldStart("ticker") - e.Str(s.Ticker) - } +func (s *GetTonConnectPayloadOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("decimals") - e.Int(s.Decimals) + e.FieldStart("payload") + e.Str(s.Payload) } } -var jsonFieldsNameOfInscriptionMintAction = [5]string{ - 0: "recipient", - 1: "amount", - 2: "type", - 3: "ticker", - 4: "decimals", +var jsonFieldsNameOfGetTonConnectPayloadOK = [1]string{ + 0: "payload", } -// Decode decodes InscriptionMintAction from json. -func (s *InscriptionMintAction) Decode(d *jx.Decoder) error { +// Decode decodes GetTonConnectPayloadOK from json. +func (s *GetTonConnectPayloadOK) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode InscriptionMintAction to nil") + return errors.New("invalid: unable to decode GetTonConnectPayloadOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "recipient": + case "payload": requiredBitSet[0] |= 1 << 0 - if err := func() error { - if err := s.Recipient.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"recipient\"") - } - case "amount": - requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.Amount = string(v) + s.Payload = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") - } - case "type": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - if err := s.Type.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"type\"") - } - case "ticker": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Str() - s.Ticker = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"ticker\"") - } - case "decimals": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Int() - s.Decimals = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"decimals\"") + return errors.Wrap(err, "decode field \"payload\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode InscriptionMintAction") + return errors.Wrap(err, "decode GetTonConnectPayloadOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00011111, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -21650,8 +22965,8 @@ func (s *InscriptionMintAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfInscriptionMintAction) { - name = jsonFieldsNameOfInscriptionMintAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetTonConnectPayloadOK) { + name = jsonFieldsNameOfGetTonConnectPayloadOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21672,205 +22987,216 @@ func (s *InscriptionMintAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *InscriptionMintAction) MarshalJSON() ([]byte, error) { +func (s *GetTonConnectPayloadOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *InscriptionMintAction) UnmarshalJSON(data []byte) error { +func (s *GetTonConnectPayloadOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode encodes InscriptionMintActionType as json. -func (s InscriptionMintActionType) Encode(e *jx.Encoder) { - e.Str(string(s)) +// Encode implements json.Marshaler. +func (s *ImagePreview) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() } -// Decode decodes InscriptionMintActionType from json. -func (s *InscriptionMintActionType) Decode(d *jx.Decoder) error { +// encodeFields encodes fields. +func (s *ImagePreview) encodeFields(e *jx.Encoder) { + { + e.FieldStart("resolution") + e.Str(s.Resolution) + } + { + e.FieldStart("url") + e.Str(s.URL) + } +} + +var jsonFieldsNameOfImagePreview = [2]string{ + 0: "resolution", + 1: "url", +} + +// Decode decodes ImagePreview from json. +func (s *ImagePreview) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode InscriptionMintActionType to nil") + return errors.New("invalid: unable to decode ImagePreview to nil") } - v, err := d.StrBytes() - if err != nil { - return err + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "resolution": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Resolution = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"resolution\"") + } + case "url": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.URL = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"url\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode ImagePreview") } - // Try to use constant string. - switch InscriptionMintActionType(v) { - case InscriptionMintActionTypeTon20: - *s = InscriptionMintActionTypeTon20 - case InscriptionMintActionTypeGram20: - *s = InscriptionMintActionTypeGram20 - default: - *s = InscriptionMintActionType(v) + // 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(jsonFieldsNameOfImagePreview) { + name = jsonFieldsNameOfImagePreview[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 InscriptionMintActionType) MarshalJSON() ([]byte, error) { +func (s *ImagePreview) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *InscriptionMintActionType) UnmarshalJSON(data []byte) error { +func (s *ImagePreview) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *InscriptionTransferAction) Encode(e *jx.Encoder) { +func (s *InitStateRaw) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *InscriptionTransferAction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("sender") - s.Sender.Encode(e) - } - { - e.FieldStart("recipient") - s.Recipient.Encode(e) - } - { - e.FieldStart("amount") - e.Str(s.Amount) - } - { - if s.Comment.Set { - e.FieldStart("comment") - s.Comment.Encode(e) - } - } +func (s *InitStateRaw) encodeFields(e *jx.Encoder) { { - e.FieldStart("type") - s.Type.Encode(e) + e.FieldStart("workchain") + e.Int32(s.Workchain) } { - e.FieldStart("ticker") - e.Str(s.Ticker) + e.FieldStart("root_hash") + e.Str(s.RootHash) } { - e.FieldStart("decimals") - e.Int(s.Decimals) + e.FieldStart("file_hash") + e.Str(s.FileHash) } } -var jsonFieldsNameOfInscriptionTransferAction = [7]string{ - 0: "sender", - 1: "recipient", - 2: "amount", - 3: "comment", - 4: "type", - 5: "ticker", - 6: "decimals", +var jsonFieldsNameOfInitStateRaw = [3]string{ + 0: "workchain", + 1: "root_hash", + 2: "file_hash", } -// Decode decodes InscriptionTransferAction from json. -func (s *InscriptionTransferAction) Decode(d *jx.Decoder) error { +// Decode decodes InitStateRaw from json. +func (s *InitStateRaw) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode InscriptionTransferAction to nil") + return errors.New("invalid: unable to decode InitStateRaw to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "sender": + case "workchain": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Sender.Decode(d); err != nil { + v, err := d.Int32() + s.Workchain = int32(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"sender\"") + return errors.Wrap(err, "decode field \"workchain\"") } - case "recipient": + case "root_hash": requiredBitSet[0] |= 1 << 1 - if err := func() error { - if err := s.Recipient.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"recipient\"") - } - case "amount": - requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.Amount = string(v) + s.RootHash = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") - } - case "comment": - if err := func() error { - s.Comment.Reset() - if err := s.Comment.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"comment\"") - } - case "type": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - if err := s.Type.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"type\"") + return errors.Wrap(err, "decode field \"root_hash\"") } - case "ticker": - requiredBitSet[0] |= 1 << 5 + case "file_hash": + requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.Ticker = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"ticker\"") - } - case "decimals": - requiredBitSet[0] |= 1 << 6 - if err := func() error { - v, err := d.Int() - s.Decimals = int(v) + s.FileHash = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"decimals\"") + return errors.Wrap(err, "decode field \"file_hash\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode InscriptionTransferAction") + return errors.Wrap(err, "decode InitStateRaw") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b01110111, + 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -21882,8 +23208,8 @@ func (s *InscriptionTransferAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfInscriptionTransferAction) { - name = jsonFieldsNameOfInscriptionTransferAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfInitStateRaw) { + name = jsonFieldsNameOfInitStateRaw[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21904,54 +23230,14 @@ func (s *InscriptionTransferAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *InscriptionTransferAction) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *InscriptionTransferAction) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes InscriptionTransferActionType as json. -func (s InscriptionTransferActionType) Encode(e *jx.Encoder) { - e.Str(string(s)) -} - -// Decode decodes InscriptionTransferActionType from json. -func (s *InscriptionTransferActionType) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode InscriptionTransferActionType to nil") - } - v, err := d.StrBytes() - if err != nil { - return err - } - // Try to use constant string. - switch InscriptionTransferActionType(v) { - case InscriptionTransferActionTypeTon20: - *s = InscriptionTransferActionTypeTon20 - case InscriptionTransferActionTypeGram20: - *s = InscriptionTransferActionTypeGram20 - default: - *s = InscriptionTransferActionType(v) - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s InscriptionTransferActionType) MarshalJSON() ([]byte, error) { +func (s *InitStateRaw) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *InscriptionTransferActionType) UnmarshalJSON(data []byte) error { +func (s *InitStateRaw) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } @@ -23069,6 +24355,10 @@ func (s *JettonInfo) encodeFields(e *jx.Encoder) { e.FieldStart("metadata") s.Metadata.Encode(e) } + { + e.FieldStart("preview") + e.Str(s.Preview) + } { e.FieldStart("verification") s.Verification.Encode(e) @@ -23079,13 +24369,14 @@ func (s *JettonInfo) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfJettonInfo = [6]string{ +var jsonFieldsNameOfJettonInfo = [7]string{ 0: "mintable", 1: "total_supply", 2: "admin", 3: "metadata", - 4: "verification", - 5: "holders_count", + 4: "preview", + 5: "verification", + 6: "holders_count", } // Decode decodes JettonInfo from json. @@ -23141,8 +24432,20 @@ func (s *JettonInfo) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"metadata\"") } - case "verification": + case "preview": requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Str() + s.Preview = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"preview\"") + } + case "verification": + requiredBitSet[0] |= 1 << 5 if err := func() error { if err := s.Verification.Decode(d); err != nil { return err @@ -23152,7 +24455,7 @@ func (s *JettonInfo) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"verification\"") } case "holders_count": - requiredBitSet[0] |= 1 << 5 + requiredBitSet[0] |= 1 << 6 if err := func() error { v, err := d.Int32() s.HoldersCount = int32(v) @@ -23173,7 +24476,7 @@ func (s *JettonInfo) Decode(d *jx.Decoder) error { // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00111011, + 0b01111011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -23286,9 +24589,15 @@ func (s *JettonMetadata) encodeFields(e *jx.Encoder) { e.ArrEnd() } } + { + if s.CustomPayloadAPIURI.Set { + e.FieldStart("custom_payload_api_uri") + s.CustomPayloadAPIURI.Encode(e) + } + } } -var jsonFieldsNameOfJettonMetadata = [9]string{ +var jsonFieldsNameOfJettonMetadata = [10]string{ 0: "address", 1: "name", 2: "symbol", @@ -23298,6 +24607,7 @@ var jsonFieldsNameOfJettonMetadata = [9]string{ 6: "social", 7: "websites", 8: "catalogs", + 9: "custom_payload_api_uri", } // Decode decodes JettonMetadata from json. @@ -23434,6 +24744,16 @@ func (s *JettonMetadata) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"catalogs\"") } + case "custom_payload_api_uri": + if err := func() error { + s.CustomPayloadAPIURI.Reset() + if err := s.CustomPayloadAPIURI.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"custom_payload_api_uri\"") + } default: return d.Skip() } @@ -23634,6 +24954,435 @@ func (s *JettonMintAction) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *JettonOperation) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *JettonOperation) encodeFields(e *jx.Encoder) { + { + e.FieldStart("operation") + s.Operation.Encode(e) + } + { + e.FieldStart("utime") + e.Int64(s.Utime) + } + { + e.FieldStart("lt") + e.Int64(s.Lt) + } + { + e.FieldStart("transaction_hash") + e.Str(s.TransactionHash) + } + { + if s.Source.Set { + e.FieldStart("source") + s.Source.Encode(e) + } + } + { + if s.Destination.Set { + e.FieldStart("destination") + s.Destination.Encode(e) + } + } + { + e.FieldStart("amount") + e.Str(s.Amount) + } + { + e.FieldStart("jetton") + s.Jetton.Encode(e) + } + { + e.FieldStart("trace_id") + e.Str(s.TraceID) + } + { + e.FieldStart("query_id") + e.Str(s.QueryID) + } + { + if len(s.Payload) != 0 { + e.FieldStart("payload") + e.Raw(s.Payload) + } + } +} + +var jsonFieldsNameOfJettonOperation = [11]string{ + 0: "operation", + 1: "utime", + 2: "lt", + 3: "transaction_hash", + 4: "source", + 5: "destination", + 6: "amount", + 7: "jetton", + 8: "trace_id", + 9: "query_id", + 10: "payload", +} + +// Decode decodes JettonOperation from json. +func (s *JettonOperation) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode JettonOperation to nil") + } + var requiredBitSet [2]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "operation": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Operation.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"operation\"") + } + case "utime": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int64() + s.Utime = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"utime\"") + } + case "lt": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int64() + s.Lt = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"lt\"") + } + case "transaction_hash": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.TransactionHash = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"transaction_hash\"") + } + case "source": + if err := func() error { + s.Source.Reset() + if err := s.Source.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"source\"") + } + case "destination": + if err := func() error { + s.Destination.Reset() + if err := s.Destination.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"destination\"") + } + case "amount": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + v, err := d.Str() + s.Amount = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"amount\"") + } + case "jetton": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + if err := s.Jetton.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"jetton\"") + } + case "trace_id": + requiredBitSet[1] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.TraceID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"trace_id\"") + } + case "query_id": + requiredBitSet[1] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.QueryID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"query_id\"") + } + case "payload": + if err := func() error { + v, err := d.RawAppend(nil) + s.Payload = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"payload\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode JettonOperation") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b11001111, + 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(jsonFieldsNameOfJettonOperation) { + name = jsonFieldsNameOfJettonOperation[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 *JettonOperation) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *JettonOperation) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes JettonOperationOperation as json. +func (s JettonOperationOperation) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes JettonOperationOperation from json. +func (s *JettonOperationOperation) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode JettonOperationOperation to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch JettonOperationOperation(v) { + case JettonOperationOperationTransfer: + *s = JettonOperationOperationTransfer + case JettonOperationOperationMint: + *s = JettonOperationOperationMint + case JettonOperationOperationBurn: + *s = JettonOperationOperationBurn + default: + *s = JettonOperationOperation(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s JettonOperationOperation) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *JettonOperationOperation) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *JettonOperations) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *JettonOperations) encodeFields(e *jx.Encoder) { + { + e.FieldStart("operations") + e.ArrStart() + for _, elem := range s.Operations { + elem.Encode(e) + } + e.ArrEnd() + } + { + if s.NextFrom.Set { + e.FieldStart("next_from") + s.NextFrom.Encode(e) + } + } +} + +var jsonFieldsNameOfJettonOperations = [2]string{ + 0: "operations", + 1: "next_from", +} + +// Decode decodes JettonOperations from json. +func (s *JettonOperations) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode JettonOperations to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "operations": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Operations = make([]JettonOperation, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem JettonOperation + if err := elem.Decode(d); err != nil { + return err + } + s.Operations = append(s.Operations, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"operations\"") + } + case "next_from": + if err := func() error { + s.NextFrom.Reset() + if err := s.NextFrom.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"next_from\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode JettonOperations") + } + // 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(jsonFieldsNameOfJettonOperations) { + name = jsonFieldsNameOfJettonOperations[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 *JettonOperations) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *JettonOperations) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *JettonPreview) Encode(e *jx.Encoder) { e.ObjStart() @@ -23667,15 +25416,27 @@ func (s *JettonPreview) encodeFields(e *jx.Encoder) { e.FieldStart("verification") s.Verification.Encode(e) } + { + if s.CustomPayloadAPIURI.Set { + e.FieldStart("custom_payload_api_uri") + s.CustomPayloadAPIURI.Encode(e) + } + } + { + e.FieldStart("score") + e.Int32(s.Score) + } } -var jsonFieldsNameOfJettonPreview = [6]string{ +var jsonFieldsNameOfJettonPreview = [8]string{ 0: "address", 1: "name", 2: "symbol", 3: "decimals", 4: "image", 5: "verification", + 6: "custom_payload_api_uri", + 7: "score", } // Decode decodes JettonPreview from json. @@ -23757,6 +25518,28 @@ func (s *JettonPreview) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"verification\"") } + case "custom_payload_api_uri": + if err := func() error { + s.CustomPayloadAPIURI.Reset() + if err := s.CustomPayloadAPIURI.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"custom_payload_api_uri\"") + } + case "score": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + v, err := d.Int32() + s.Score = int32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"score\"") + } default: return d.Skip() } @@ -23767,7 +25550,7 @@ func (s *JettonPreview) Decode(d *jx.Decoder) error { // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00111111, + 0b10111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -23950,7 +25733,7 @@ func (s *JettonSwapAction) Encode(e *jx.Encoder) { func (s *JettonSwapAction) encodeFields(e *jx.Encoder) { { e.FieldStart("dex") - s.Dex.Encode(e) + e.Str(s.Dex) } { e.FieldStart("amount_in") @@ -24018,7 +25801,9 @@ func (s *JettonSwapAction) Decode(d *jx.Decoder) error { case "dex": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Dex.Decode(d); err != nil { + v, err := d.Str() + s.Dex = string(v) + if err != nil { return err } return nil @@ -24166,48 +25951,6 @@ func (s *JettonSwapAction) UnmarshalJSON(data []byte) error { return s.Decode(d) } -// Encode encodes JettonSwapActionDex as json. -func (s JettonSwapActionDex) Encode(e *jx.Encoder) { - e.Str(string(s)) -} - -// Decode decodes JettonSwapActionDex from json. -func (s *JettonSwapActionDex) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode JettonSwapActionDex to nil") - } - v, err := d.StrBytes() - if err != nil { - return err - } - // Try to use constant string. - switch JettonSwapActionDex(v) { - case JettonSwapActionDexStonfi: - *s = JettonSwapActionDexStonfi - case JettonSwapActionDexDedust: - *s = JettonSwapActionDexDedust - case JettonSwapActionDexMegatonfi: - *s = JettonSwapActionDexMegatonfi - default: - *s = JettonSwapActionDex(v) - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s JettonSwapActionDex) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonSwapActionDex) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - // Encode implements json.Marshaler. func (s *JettonTransferAction) Encode(e *jx.Encoder) { e.ObjStart() @@ -24537,6 +26280,8 @@ func (s *JettonVerificationType) Decode(d *jx.Decoder) error { switch JettonVerificationType(v) { case JettonVerificationTypeWhitelist: *s = JettonVerificationTypeWhitelist + case JettonVerificationTypeGraylist: + *s = JettonVerificationTypeGraylist case JettonVerificationTypeBlacklist: *s = JettonVerificationTypeBlacklist case JettonVerificationTypeNone: @@ -24773,6 +26518,142 @@ func (s *JettonsBalances) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *LiquidityDepositAction) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *LiquidityDepositAction) encodeFields(e *jx.Encoder) { + { + e.FieldStart("protocol") + s.Protocol.Encode(e) + } + { + e.FieldStart("from") + s.From.Encode(e) + } + { + e.FieldStart("tokens") + e.ArrStart() + for _, elem := range s.Tokens { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfLiquidityDepositAction = [3]string{ + 0: "protocol", + 1: "from", + 2: "tokens", +} + +// Decode decodes LiquidityDepositAction from json. +func (s *LiquidityDepositAction) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode LiquidityDepositAction to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "protocol": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Protocol.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"protocol\"") + } + case "from": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.From.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"from\"") + } + case "tokens": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + s.Tokens = make([]VaultDepositInfo, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem VaultDepositInfo + if err := elem.Decode(d); err != nil { + return err + } + s.Tokens = append(s.Tokens, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tokens\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode LiquidityDepositAction") + } + // 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(jsonFieldsNameOfLiquidityDepositAction) { + name = jsonFieldsNameOfLiquidityDepositAction[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 *LiquidityDepositAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *LiquidityDepositAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *MarketTonRates) Encode(e *jx.Encoder) { e.ObjStart() @@ -24936,6 +26817,16 @@ func (s *Message) encodeFields(e *jx.Encoder) { e.FieldStart("value") e.Int64(s.Value) } + { + if s.ValueExtra != nil { + e.FieldStart("value_extra") + e.ArrStart() + for _, elem := range s.ValueExtra { + elem.Encode(e) + } + e.ArrEnd() + } + } { e.FieldStart("fwd_fee") e.Int64(s.FwdFee) @@ -25000,25 +26891,26 @@ func (s *Message) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfMessage = [18]string{ +var jsonFieldsNameOfMessage = [19]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: "hash", - 15: "raw_body", - 16: "decoded_op_name", - 17: "decoded_body", + 6: "value_extra", + 7: "fwd_fee", + 8: "ihr_fee", + 9: "destination", + 10: "source", + 11: "import_fee", + 12: "created_at", + 13: "op_code", + 14: "init", + 15: "hash", + 16: "raw_body", + 17: "decoded_op_name", + 18: "decoded_body", } // Decode decodes Message from json. @@ -25100,8 +26992,25 @@ func (s *Message) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"value\"") } + case "value_extra": + if err := func() error { + s.ValueExtra = make([]ExtraCurrency, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ExtraCurrency + if err := elem.Decode(d); err != nil { + return err + } + s.ValueExtra = append(s.ValueExtra, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"value_extra\"") + } case "fwd_fee": - requiredBitSet[0] |= 1 << 6 + requiredBitSet[0] |= 1 << 7 if err := func() error { v, err := d.Int64() s.FwdFee = int64(v) @@ -25113,7 +27022,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"fwd_fee\"") } case "ihr_fee": - requiredBitSet[0] |= 1 << 7 + requiredBitSet[1] |= 1 << 0 if err := func() error { v, err := d.Int64() s.IhrFee = int64(v) @@ -25145,7 +27054,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"source\"") } case "import_fee": - requiredBitSet[1] |= 1 << 2 + requiredBitSet[1] |= 1 << 3 if err := func() error { v, err := d.Int64() s.ImportFee = int64(v) @@ -25157,7 +27066,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"import_fee\"") } case "created_at": - requiredBitSet[1] |= 1 << 3 + requiredBitSet[1] |= 1 << 4 if err := func() error { v, err := d.Int64() s.CreatedAt = int64(v) @@ -25189,7 +27098,7 @@ func (s *Message) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"init\"") } case "hash": - requiredBitSet[1] |= 1 << 6 + requiredBitSet[1] |= 1 << 7 if err := func() error { v, err := d.Str() s.Hash = string(v) @@ -25241,8 +27150,8 @@ func (s *Message) Decode(d *jx.Decoder) error { // Validate required fields. var failures []validate.FieldError for i, mask := range [3]uint8{ - 0b11111111, - 0b01001100, + 0b10111111, + 0b10011001, 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { @@ -25455,6 +27364,232 @@ func (s *MessageMsgType) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *Metadata) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *Metadata) encodeFields(e *jx.Encoder) { + { + e.FieldStart("encrypted_binary") + e.Str(s.EncryptedBinary) + } + { + if s.DecryptionKey.Set { + e.FieldStart("decryption_key") + s.DecryptionKey.Encode(e) + } + } +} + +var jsonFieldsNameOfMetadata = [2]string{ + 0: "encrypted_binary", + 1: "decryption_key", +} + +// Decode decodes Metadata from json. +func (s *Metadata) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode Metadata to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "encrypted_binary": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.EncryptedBinary = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"encrypted_binary\"") + } + case "decryption_key": + if err := func() error { + s.DecryptionKey.Reset() + if err := s.DecryptionKey.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"decryption_key\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode Metadata") + } + // 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(jsonFieldsNameOfMetadata) { + name = jsonFieldsNameOfMetadata[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 *Metadata) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *Metadata) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *Method) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *Method) encodeFields(e *jx.Encoder) { + { + e.FieldStart("id") + e.Int64(s.ID) + } + { + e.FieldStart("method") + e.Str(s.Method) + } +} + +var jsonFieldsNameOfMethod = [2]string{ + 0: "id", + 1: "method", +} + +// Decode decodes Method from json. +func (s *Method) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode Method 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 "method": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Method = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"method\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode Method") + } + // 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(jsonFieldsNameOfMethod) { + name = jsonFieldsNameOfMethod[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 *Method) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *Method) 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() @@ -26076,7 +28211,7 @@ func (s *Multisig) encodeFields(e *jx.Encoder) { } { e.FieldStart("seqno") - e.Int64(s.Seqno) + e.Str(s.Seqno) } { e.FieldStart("threshold") @@ -26141,8 +28276,8 @@ func (s *Multisig) Decode(d *jx.Decoder) error { case "seqno": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int64() - s.Seqno = int64(v) + v, err := d.Str() + s.Seqno = string(v) if err != nil { return err } @@ -26291,7 +28426,7 @@ func (s *MultisigOrder) encodeFields(e *jx.Encoder) { } { e.FieldStart("order_seqno") - e.Int64(s.OrderSeqno) + e.Str(s.OrderSeqno) } { e.FieldStart("threshold") @@ -26321,17 +28456,43 @@ func (s *MultisigOrder) encodeFields(e *jx.Encoder) { e.FieldStart("risk") s.Risk.Encode(e) } + { + e.FieldStart("creation_date") + e.Int64(s.CreationDate) + } + { + e.FieldStart("signed_by") + e.ArrStart() + for _, elem := range s.SignedBy { + e.Str(elem) + } + e.ArrEnd() + } + { + e.FieldStart("multisig_address") + e.Str(s.MultisigAddress) + } + { + if s.ChangingParameters.Set { + e.FieldStart("changing_parameters") + s.ChangingParameters.Encode(e) + } + } } -var jsonFieldsNameOfMultisigOrder = [8]string{ - 0: "address", - 1: "order_seqno", - 2: "threshold", - 3: "sent_for_execution", - 4: "signers", - 5: "approvals_num", - 6: "expiration_date", - 7: "risk", +var jsonFieldsNameOfMultisigOrder = [12]string{ + 0: "address", + 1: "order_seqno", + 2: "threshold", + 3: "sent_for_execution", + 4: "signers", + 5: "approvals_num", + 6: "expiration_date", + 7: "risk", + 8: "creation_date", + 9: "signed_by", + 10: "multisig_address", + 11: "changing_parameters", } // Decode decodes MultisigOrder from json. @@ -26339,7 +28500,7 @@ func (s *MultisigOrder) Decode(d *jx.Decoder) error { if s == nil { return errors.New("invalid: unable to decode MultisigOrder to nil") } - var requiredBitSet [1]uint8 + var requiredBitSet [2]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { @@ -26358,8 +28519,8 @@ func (s *MultisigOrder) Decode(d *jx.Decoder) error { case "order_seqno": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int64() - s.OrderSeqno = int64(v) + v, err := d.Str() + s.OrderSeqno = string(v) if err != nil { return err } @@ -26445,6 +28606,60 @@ func (s *MultisigOrder) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"risk\"") } + case "creation_date": + requiredBitSet[1] |= 1 << 0 + if err := func() error { + v, err := d.Int64() + s.CreationDate = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"creation_date\"") + } + case "signed_by": + requiredBitSet[1] |= 1 << 1 + if err := func() error { + s.SignedBy = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.SignedBy = append(s.SignedBy, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"signed_by\"") + } + case "multisig_address": + requiredBitSet[1] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.MultisigAddress = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"multisig_address\"") + } + case "changing_parameters": + if err := func() error { + s.ChangingParameters.Reset() + if err := s.ChangingParameters.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"changing_parameters\"") + } default: return d.Skip() } @@ -26454,8 +28669,9 @@ func (s *MultisigOrder) Decode(d *jx.Decoder) error { } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ + for i, mask := range [2]uint8{ 0b11111111, + 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -26501,6 +28717,160 @@ func (s *MultisigOrder) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *MultisigOrderChangingParameters) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *MultisigOrderChangingParameters) encodeFields(e *jx.Encoder) { + { + e.FieldStart("threshold") + e.Int32(s.Threshold) + } + { + e.FieldStart("signers") + e.ArrStart() + for _, elem := range s.Signers { + e.Str(elem) + } + e.ArrEnd() + } + { + e.FieldStart("proposers") + e.ArrStart() + for _, elem := range s.Proposers { + e.Str(elem) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfMultisigOrderChangingParameters = [3]string{ + 0: "threshold", + 1: "signers", + 2: "proposers", +} + +// Decode decodes MultisigOrderChangingParameters from json. +func (s *MultisigOrderChangingParameters) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode MultisigOrderChangingParameters to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "threshold": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int32() + s.Threshold = int32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"threshold\"") + } + case "signers": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + s.Signers = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Signers = append(s.Signers, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"signers\"") + } + case "proposers": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + s.Proposers = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Proposers = append(s.Proposers, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"proposers\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode MultisigOrderChangingParameters") + } + // 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(jsonFieldsNameOfMultisigOrderChangingParameters) { + name = jsonFieldsNameOfMultisigOrderChangingParameters[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 *MultisigOrderChangingParameters) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *MultisigOrderChangingParameters) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *Multisigs) Encode(e *jx.Encoder) { e.ObjStart() @@ -26677,8 +29047,6 @@ func (s *NftApprovedByItem) Decode(d *jx.Decoder) error { *s = NftApprovedByItemGetgems case NftApprovedByItemTonkeeper: *s = NftApprovedByItemTonkeeper - case NftApprovedByItemTonDiamonds: - *s = NftApprovedByItemTonDiamonds default: *s = NftApprovedByItem(v) } @@ -27131,7 +29499,11 @@ func (s *NftItem) encodeFields(e *jx.Encoder) { } { e.FieldStart("approved_by") - s.ApprovedBy.Encode(e) + e.ArrStart() + for _, elem := range s.ApprovedBy { + elem.Encode(e) + } + e.ArrEnd() } { if s.IncludeCnft.Set { @@ -27275,7 +29647,15 @@ func (s *NftItem) Decode(d *jx.Decoder) error { case "approved_by": requiredBitSet[1] |= 1 << 1 if err := func() error { - if err := s.ApprovedBy.Decode(d); err != nil { + s.ApprovedBy = make([]NftItemApprovedByItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NftItemApprovedByItem + if err := elem.Decode(d); err != nil { + return err + } + s.ApprovedBy = append(s.ApprovedBy, elem) + return nil + }); err != nil { return err } return nil @@ -27359,6 +29739,46 @@ func (s *NftItem) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes NftItemApprovedByItem as json. +func (s NftItemApprovedByItem) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes NftItemApprovedByItem from json. +func (s *NftItemApprovedByItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NftItemApprovedByItem to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch NftItemApprovedByItem(v) { + case NftItemApprovedByItemGetgems: + *s = NftItemApprovedByItemGetgems + case NftItemApprovedByItemTonkeeper: + *s = NftItemApprovedByItemTonkeeper + default: + *s = NftItemApprovedByItem(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s NftItemApprovedByItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NftItemApprovedByItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *NftItemCollection) Encode(e *jx.Encoder) { e.ObjStart() @@ -27852,114 +30272,156 @@ func (s *NftItems) UnmarshalJSON(data []byte) error { } // Encode implements json.Marshaler. -func (s *NftPurchaseAction) Encode(e *jx.Encoder) { +func (s *NftOperation) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *NftPurchaseAction) encodeFields(e *jx.Encoder) { +func (s *NftOperation) encodeFields(e *jx.Encoder) { { - e.FieldStart("auction_type") - s.AuctionType.Encode(e) + e.FieldStart("operation") + e.Str(s.Operation) } { - e.FieldStart("amount") - s.Amount.Encode(e) + e.FieldStart("utime") + e.Int64(s.Utime) } { - e.FieldStart("nft") - s.Nft.Encode(e) + e.FieldStart("lt") + e.Int64(s.Lt) } { - e.FieldStart("seller") - s.Seller.Encode(e) + e.FieldStart("transaction_hash") + e.Str(s.TransactionHash) } { - e.FieldStart("buyer") - s.Buyer.Encode(e) + if s.Source.Set { + e.FieldStart("source") + s.Source.Encode(e) + } + } + { + if s.Destination.Set { + e.FieldStart("destination") + s.Destination.Encode(e) + } + } + { + e.FieldStart("item") + s.Item.Encode(e) } } -var jsonFieldsNameOfNftPurchaseAction = [5]string{ - 0: "auction_type", - 1: "amount", - 2: "nft", - 3: "seller", - 4: "buyer", +var jsonFieldsNameOfNftOperation = [7]string{ + 0: "operation", + 1: "utime", + 2: "lt", + 3: "transaction_hash", + 4: "source", + 5: "destination", + 6: "item", } -// Decode decodes NftPurchaseAction from json. -func (s *NftPurchaseAction) Decode(d *jx.Decoder) error { +// Decode decodes NftOperation from json. +func (s *NftOperation) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode NftPurchaseAction to nil") + return errors.New("invalid: unable to decode NftOperation to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "auction_type": + case "operation": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.AuctionType.Decode(d); err != nil { + v, err := d.Str() + s.Operation = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"auction_type\"") + return errors.Wrap(err, "decode field \"operation\"") } - case "amount": + case "utime": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Amount.Decode(d); err != nil { + v, err := d.Int64() + s.Utime = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") + return errors.Wrap(err, "decode field \"utime\"") } - case "nft": + case "lt": requiredBitSet[0] |= 1 << 2 if err := func() error { - if err := s.Nft.Decode(d); err != nil { + v, err := d.Int64() + s.Lt = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"nft\"") + return errors.Wrap(err, "decode field \"lt\"") } - case "seller": + case "transaction_hash": requiredBitSet[0] |= 1 << 3 if err := func() error { - if err := s.Seller.Decode(d); err != nil { + v, err := d.Str() + s.TransactionHash = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"seller\"") + return errors.Wrap(err, "decode field \"transaction_hash\"") } - case "buyer": - requiredBitSet[0] |= 1 << 4 + case "source": if err := func() error { - if err := s.Buyer.Decode(d); err != nil { + s.Source.Reset() + if err := s.Source.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"buyer\"") + return errors.Wrap(err, "decode field \"source\"") + } + case "destination": + if err := func() error { + s.Destination.Reset() + if err := s.Destination.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"destination\"") + } + case "item": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + if err := s.Item.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"item\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode NftPurchaseAction") + return errors.Wrap(err, "decode NftOperation") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00011111, + 0b01001111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -27971,8 +30433,8 @@ func (s *NftPurchaseAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfNftPurchaseAction) { - name = jsonFieldsNameOfNftPurchaseAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfNftOperation) { + name = jsonFieldsNameOfNftOperation[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -27993,124 +30455,401 @@ func (s *NftPurchaseAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *NftPurchaseAction) MarshalJSON() ([]byte, error) { +func (s *NftOperation) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftPurchaseAction) UnmarshalJSON(data []byte) error { +func (s *NftOperation) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode encodes NftPurchaseActionAuctionType as json. -func (s NftPurchaseActionAuctionType) Encode(e *jx.Encoder) { - e.Str(string(s)) +// Encode implements json.Marshaler. +func (s *NftOperations) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() } -// Decode decodes NftPurchaseActionAuctionType from json. -func (s *NftPurchaseActionAuctionType) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode NftPurchaseActionAuctionType to nil") - } - v, err := d.StrBytes() - if err != nil { - return err +// encodeFields encodes fields. +func (s *NftOperations) encodeFields(e *jx.Encoder) { + { + e.FieldStart("operations") + e.ArrStart() + for _, elem := range s.Operations { + elem.Encode(e) + } + e.ArrEnd() } - // Try to use constant string. - switch NftPurchaseActionAuctionType(v) { - case NftPurchaseActionAuctionTypeDNSTon: - *s = NftPurchaseActionAuctionTypeDNSTon - case NftPurchaseActionAuctionTypeDNSTg: - *s = NftPurchaseActionAuctionTypeDNSTg - case NftPurchaseActionAuctionTypeNUMBERTg: - *s = NftPurchaseActionAuctionTypeNUMBERTg - case NftPurchaseActionAuctionTypeGetgems: - *s = NftPurchaseActionAuctionTypeGetgems - default: - *s = NftPurchaseActionAuctionType(v) + { + if s.NextFrom.Set { + e.FieldStart("next_from") + s.NextFrom.Encode(e) + } } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s NftPurchaseActionAuctionType) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil } -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftPurchaseActionAuctionType) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) +var jsonFieldsNameOfNftOperations = [2]string{ + 0: "operations", + 1: "next_from", } -// Encode encodes AccountAddress as json. -func (o OptAccountAddress) Encode(e *jx.Encoder) { - if !o.Set { - return +// Decode decodes NftOperations from json. +func (s *NftOperations) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NftOperations to nil") } - o.Value.Encode(e) -} + var requiredBitSet [1]uint8 -// Decode decodes AccountAddress from json. -func (o *OptAccountAddress) Decode(d *jx.Decoder) error { - if o == nil { - return errors.New("invalid: unable to decode OptAccountAddress to nil") + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "operations": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Operations = make([]NftOperation, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NftOperation + if err := elem.Decode(d); err != nil { + return err + } + s.Operations = append(s.Operations, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"operations\"") + } + case "next_from": + if err := func() error { + s.NextFrom.Reset() + if err := s.NextFrom.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"next_from\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode NftOperations") } - o.Set = true - if err := o.Value.Decode(d); err != nil { - return err + // 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(jsonFieldsNameOfNftOperations) { + name = jsonFieldsNameOfNftOperations[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 OptAccountAddress) MarshalJSON() ([]byte, error) { +func (s *NftOperations) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptAccountAddress) UnmarshalJSON(data []byte) error { +func (s *NftOperations) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode encodes AccountCurrenciesBalance as json. -func (o OptAccountCurrenciesBalance) Encode(e *jx.Encoder) { - if !o.Set { - return - } - o.Value.Encode(e) +// Encode implements json.Marshaler. +func (s *NftPurchaseAction) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() } -// Decode decodes AccountCurrenciesBalance from json. -func (o *OptAccountCurrenciesBalance) Decode(d *jx.Decoder) error { - if o == nil { - return errors.New("invalid: unable to decode OptAccountCurrenciesBalance to nil") +// encodeFields encodes fields. +func (s *NftPurchaseAction) encodeFields(e *jx.Encoder) { + { + e.FieldStart("auction_type") + s.AuctionType.Encode(e) } - o.Set = true - o.Value = make(AccountCurrenciesBalance) - if err := o.Value.Decode(d); err != nil { - return err + { + e.FieldStart("amount") + s.Amount.Encode(e) } - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s OptAccountCurrenciesBalance) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. + { + e.FieldStart("nft") + s.Nft.Encode(e) + } + { + e.FieldStart("seller") + s.Seller.Encode(e) + } + { + e.FieldStart("buyer") + s.Buyer.Encode(e) + } +} + +var jsonFieldsNameOfNftPurchaseAction = [5]string{ + 0: "auction_type", + 1: "amount", + 2: "nft", + 3: "seller", + 4: "buyer", +} + +// Decode decodes NftPurchaseAction from json. +func (s *NftPurchaseAction) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NftPurchaseAction to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "auction_type": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.AuctionType.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"auction_type\"") + } + case "amount": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Amount.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"amount\"") + } + case "nft": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.Nft.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"nft\"") + } + case "seller": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + if err := s.Seller.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"seller\"") + } + case "buyer": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + if err := s.Buyer.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"buyer\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode NftPurchaseAction") + } + // 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(jsonFieldsNameOfNftPurchaseAction) { + name = jsonFieldsNameOfNftPurchaseAction[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 *NftPurchaseAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NftPurchaseAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes NftPurchaseActionAuctionType as json. +func (s NftPurchaseActionAuctionType) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes NftPurchaseActionAuctionType from json. +func (s *NftPurchaseActionAuctionType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NftPurchaseActionAuctionType to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch NftPurchaseActionAuctionType(v) { + case NftPurchaseActionAuctionTypeDNSTon: + *s = NftPurchaseActionAuctionTypeDNSTon + case NftPurchaseActionAuctionTypeDNSTg: + *s = NftPurchaseActionAuctionTypeDNSTg + case NftPurchaseActionAuctionTypeNUMBERTg: + *s = NftPurchaseActionAuctionTypeNUMBERTg + case NftPurchaseActionAuctionTypeGetgems: + *s = NftPurchaseActionAuctionTypeGetgems + default: + *s = NftPurchaseActionAuctionType(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s NftPurchaseActionAuctionType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NftPurchaseActionAuctionType) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes AccountAddress as json. +func (o OptAccountAddress) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes AccountAddress from json. +func (o *OptAccountAddress) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptAccountAddress to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptAccountAddress) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptAccountAddress) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes AccountCurrenciesBalance as json. +func (o OptAccountCurrenciesBalance) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes AccountCurrenciesBalance from json. +func (o *OptAccountCurrenciesBalance) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptAccountCurrenciesBalance to nil") + } + o.Set = true + o.Value = make(AccountCurrenciesBalance) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptAccountCurrenciesBalance) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. func (s *OptAccountCurrenciesBalance) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) @@ -28149,18 +30888,18 @@ func (s *OptActionPhase) UnmarshalJSON(data []byte) error { return s.Decode(d) } -// Encode encodes AuctionBidAction as json. -func (o OptAuctionBidAction) Encode(e *jx.Encoder) { +// Encode encodes AddExtensionAction as json. +func (o OptAddExtensionAction) Encode(e *jx.Encoder) { if !o.Set { return } o.Value.Encode(e) } -// Decode decodes AuctionBidAction from json. -func (o *OptAuctionBidAction) Decode(d *jx.Decoder) error { +// Decode decodes AddExtensionAction from json. +func (o *OptAddExtensionAction) Decode(d *jx.Decoder) error { if o == nil { - return errors.New("invalid: unable to decode OptAuctionBidAction to nil") + return errors.New("invalid: unable to decode OptAddExtensionAction to nil") } o.Set = true if err := o.Value.Decode(d); err != nil { @@ -28170,30 +30909,30 @@ func (o *OptAuctionBidAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s OptAuctionBidAction) MarshalJSON() ([]byte, error) { +func (s OptAddExtensionAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptAuctionBidAction) UnmarshalJSON(data []byte) error { +func (s *OptAddExtensionAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode encodes BlockCurrencyCollection as json. -func (o OptBlockCurrencyCollection) Encode(e *jx.Encoder) { +// Encode encodes AuctionBidAction as json. +func (o OptAuctionBidAction) 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 { +// Decode decodes AuctionBidAction from json. +func (o *OptAuctionBidAction) Decode(d *jx.Decoder) error { if o == nil { - return errors.New("invalid: unable to decode OptBlockCurrencyCollection to nil") + return errors.New("invalid: unable to decode OptAuctionBidAction to nil") } o.Set = true if err := o.Value.Decode(d); err != nil { @@ -28203,30 +30942,30 @@ func (o *OptBlockCurrencyCollection) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s OptBlockCurrencyCollection) MarshalJSON() ([]byte, error) { +func (s OptAuctionBidAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptBlockCurrencyCollection) UnmarshalJSON(data []byte) error { +func (s *OptAuctionBidAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode encodes BlockchainAccountInspectCompiler as json. -func (o OptBlockchainAccountInspectCompiler) Encode(e *jx.Encoder) { +// Encode encodes BlockCurrencyCollection as json. +func (o OptBlockCurrencyCollection) Encode(e *jx.Encoder) { if !o.Set { return } - e.Str(string(o.Value)) + o.Value.Encode(e) } -// Decode decodes BlockchainAccountInspectCompiler from json. -func (o *OptBlockchainAccountInspectCompiler) Decode(d *jx.Decoder) error { +// Decode decodes BlockCurrencyCollection from json. +func (o *OptBlockCurrencyCollection) Decode(d *jx.Decoder) error { if o == nil { - return errors.New("invalid: unable to decode OptBlockchainAccountInspectCompiler to nil") + return errors.New("invalid: unable to decode OptBlockCurrencyCollection to nil") } o.Set = true if err := o.Value.Decode(d); err != nil { @@ -28236,14 +30975,14 @@ func (o *OptBlockchainAccountInspectCompiler) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s OptBlockchainAccountInspectCompiler) MarshalJSON() ([]byte, error) { +func (s OptBlockCurrencyCollection) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptBlockchainAccountInspectCompiler) UnmarshalJSON(data []byte) error { +func (s *OptBlockCurrencyCollection) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } @@ -28908,6 +31647,39 @@ func (s *OptBlockchainConfig43) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes BlockchainConfig45 as json. +func (o OptBlockchainConfig45) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes BlockchainConfig45 from json. +func (o *OptBlockchainConfig45) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptBlockchainConfig45 to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptBlockchainConfig45) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptBlockchainConfig45) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes BlockchainConfig5 as json. func (o OptBlockchainConfig5) Encode(e *jx.Encoder) { if !o.Set { @@ -29271,40 +32043,6 @@ func (s *OptBlockchainConfig9) UnmarshalJSON(data []byte) error { return s.Decode(d) } -// Encode encodes BlockchainRawAccountExtraBalance as json. -func (o OptBlockchainRawAccountExtraBalance) Encode(e *jx.Encoder) { - if !o.Set { - return - } - o.Value.Encode(e) -} - -// Decode decodes BlockchainRawAccountExtraBalance from json. -func (o *OptBlockchainRawAccountExtraBalance) Decode(d *jx.Decoder) error { - if o == nil { - return errors.New("invalid: unable to decode OptBlockchainRawAccountExtraBalance to nil") - } - o.Set = true - o.Value = make(BlockchainRawAccountExtraBalance) - if err := o.Value.Decode(d); err != nil { - return err - } - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s OptBlockchainRawAccountExtraBalance) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptBlockchainRawAccountExtraBalance) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - // Encode encodes bool as json. func (o OptBool) Encode(e *jx.Encoder) { if !o.Set { @@ -29637,6 +32375,39 @@ func (s *OptDecodedMessageExtInMsgDecodedWalletV4) UnmarshalJSON(data []byte) er return s.Decode(d) } +// Encode encodes DecodedMessageExtInMsgDecodedWalletV5 as json. +func (o OptDecodedMessageExtInMsgDecodedWalletV5) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes DecodedMessageExtInMsgDecodedWalletV5 from json. +func (o *OptDecodedMessageExtInMsgDecodedWalletV5) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptDecodedMessageExtInMsgDecodedWalletV5 to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptDecodedMessageExtInMsgDecodedWalletV5) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptDecodedMessageExtInMsgDecodedWalletV5) 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 { @@ -29670,6 +32441,39 @@ func (s *OptDepositStakeAction) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes DepositTokenStakeAction as json. +func (o OptDepositTokenStakeAction) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes DepositTokenStakeAction from json. +func (o *OptDepositTokenStakeAction) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptDepositTokenStakeAction to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptDepositTokenStakeAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptDepositTokenStakeAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes DomainRenewAction as json. func (o OptDomainRenewAction) Encode(e *jx.Encoder) { if !o.Set { @@ -29802,6 +32606,140 @@ func (s *OptEncryptedComment) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes ExecGetMethodWithBodyForBlockchainAccountReq as json. +func (o OptExecGetMethodWithBodyForBlockchainAccountReq) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes ExecGetMethodWithBodyForBlockchainAccountReq from json. +func (o *OptExecGetMethodWithBodyForBlockchainAccountReq) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptExecGetMethodWithBodyForBlockchainAccountReq to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptExecGetMethodWithBodyForBlockchainAccountReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptExecGetMethodWithBodyForBlockchainAccountReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes ExtraCurrencyTransferAction as json. +func (o OptExtraCurrencyTransferAction) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes ExtraCurrencyTransferAction from json. +func (o *OptExtraCurrencyTransferAction) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptExtraCurrencyTransferAction to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptExtraCurrencyTransferAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptExtraCurrencyTransferAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes float32 as json. +func (o OptFloat32) Encode(e *jx.Encoder) { + if !o.Set { + return + } + e.Float32(float32(o.Value)) +} + +// Decode decodes float32 from json. +func (o *OptFloat32) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptFloat32 to nil") + } + o.Set = true + v, err := d.Float32() + if err != nil { + return err + } + o.Value = float32(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptFloat32) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptFloat32) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes GasRelayAction as json. +func (o OptGasRelayAction) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes GasRelayAction from json. +func (o *OptGasRelayAction) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptGasRelayAction to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptGasRelayAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptGasRelayAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes GetAccountsReq as json. func (o OptGetAccountsReq) Encode(e *jx.Encoder) { if !o.Set { @@ -29835,6 +32773,72 @@ func (s *OptGetAccountsReq) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes GetJettonInfosByAddressesReq as json. +func (o OptGetJettonInfosByAddressesReq) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes GetJettonInfosByAddressesReq from json. +func (o *OptGetJettonInfosByAddressesReq) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptGetJettonInfosByAddressesReq to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptGetJettonInfosByAddressesReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptGetJettonInfosByAddressesReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes GetNftCollectionItemsByAddressesReq as json. +func (o OptGetNftCollectionItemsByAddressesReq) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes GetNftCollectionItemsByAddressesReq from json. +func (o *OptGetNftCollectionItemsByAddressesReq) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptGetNftCollectionItemsByAddressesReq to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptGetNftCollectionItemsByAddressesReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptGetNftCollectionItemsByAddressesReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes GetNftItemsByAddressesReq as json. func (o OptGetNftItemsByAddressesReq) Encode(e *jx.Encoder) { if !o.Set { @@ -29868,72 +32872,6 @@ func (s *OptGetNftItemsByAddressesReq) UnmarshalJSON(data []byte) error { return s.Decode(d) } -// Encode encodes InscriptionMintAction as json. -func (o OptInscriptionMintAction) Encode(e *jx.Encoder) { - if !o.Set { - return - } - o.Value.Encode(e) -} - -// Decode decodes InscriptionMintAction from json. -func (o *OptInscriptionMintAction) Decode(d *jx.Decoder) error { - if o == nil { - return errors.New("invalid: unable to decode OptInscriptionMintAction to nil") - } - o.Set = true - if err := o.Value.Decode(d); err != nil { - return err - } - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s OptInscriptionMintAction) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptInscriptionMintAction) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes InscriptionTransferAction as json. -func (o OptInscriptionTransferAction) Encode(e *jx.Encoder) { - if !o.Set { - return - } - o.Value.Encode(e) -} - -// Decode decodes InscriptionTransferAction from json. -func (o *OptInscriptionTransferAction) Decode(d *jx.Decoder) error { - if o == nil { - return errors.New("invalid: unable to decode OptInscriptionTransferAction to nil") - } - o.Set = true - if err := o.Value.Decode(d); err != nil { - return err - } - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s OptInscriptionTransferAction) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptInscriptionTransferAction) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - // Encode encodes int as json. func (o OptInt) Encode(e *jx.Encoder) { if !o.Set { @@ -30270,6 +33208,39 @@ func (s *OptJettonTransferAction) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes LiquidityDepositAction as json. +func (o OptLiquidityDepositAction) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes LiquidityDepositAction from json. +func (o *OptLiquidityDepositAction) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptLiquidityDepositAction to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptLiquidityDepositAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptLiquidityDepositAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes Message as json. func (o OptMessage) Encode(e *jx.Encoder) { if !o.Set { @@ -30303,6 +33274,72 @@ func (s *OptMessage) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes MessageConsequences as json. +func (o OptMessageConsequences) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes MessageConsequences from json. +func (o *OptMessageConsequences) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptMessageConsequences to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptMessageConsequences) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptMessageConsequences) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes MultisigOrderChangingParameters as json. +func (o OptMultisigOrderChangingParameters) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes MultisigOrderChangingParameters from json. +func (o *OptMultisigOrderChangingParameters) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptMultisigOrderChangingParameters to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptMultisigOrderChangingParameters) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptMultisigOrderChangingParameters) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes NftCollectionMetadata as json. func (o OptNftCollectionMetadata) Encode(e *jx.Encoder) { if !o.Set { @@ -30469,6 +33506,72 @@ func (s *OptNftPurchaseAction) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes Price as json. +func (o OptPrice) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes Price from json. +func (o *OptPrice) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptPrice to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptPrice) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptPrice) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes PurchaseAction as json. +func (o OptPurchaseAction) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes PurchaseAction from json. +func (o *OptPurchaseAction) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptPurchaseAction to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptPurchaseAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptPurchaseAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes Refund as json. func (o OptRefund) Encode(e *jx.Encoder) { if !o.Set { @@ -30502,6 +33605,39 @@ func (s *OptRefund) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes RemoveExtensionAction as json. +func (o OptRemoveExtensionAction) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes RemoveExtensionAction from json. +func (o *OptRemoveExtensionAction) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptRemoveExtensionAction to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptRemoveExtensionAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptRemoveExtensionAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes Sale as json. func (o OptSale) Encode(e *jx.Encoder) { if !o.Set { @@ -30535,6 +33671,73 @@ func (s *OptSale) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes SendBlockchainMessageReqMeta as json. +func (o OptSendBlockchainMessageReqMeta) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes SendBlockchainMessageReqMeta from json. +func (o *OptSendBlockchainMessageReqMeta) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptSendBlockchainMessageReqMeta to nil") + } + o.Set = true + o.Value = make(SendBlockchainMessageReqMeta) + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptSendBlockchainMessageReqMeta) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptSendBlockchainMessageReqMeta) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes SetSignatureAllowedAction as json. +func (o OptSetSignatureAllowedAction) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes SetSignatureAllowedAction from json. +func (o *OptSetSignatureAllowedAction) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptSetSignatureAllowedAction to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptSetSignatureAllowedAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptSetSignatureAllowedAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes SmartContractAction as json. func (o OptSmartContractAction) Encode(e *jx.Encoder) { if !o.Set { @@ -30568,6 +33771,39 @@ func (s *OptSmartContractAction) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes Source as json. +func (o OptSource) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes Source from json. +func (o *OptSource) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptSource to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptSource) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptSource) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes StateInit as json. func (o OptStateInit) Encode(e *jx.Encoder) { if !o.Set { @@ -31069,6 +34305,39 @@ func (s *OptWithdrawStakeRequestAction) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes WithdrawTokenStakeRequestAction as json. +func (o OptWithdrawTokenStakeRequestAction) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes WithdrawTokenStakeRequestAction from json. +func (o *OptWithdrawTokenStakeRequestAction) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptWithdrawTokenStakeRequestAction to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptWithdrawTokenStakeRequestAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptWithdrawTokenStakeRequestAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *Oracle) Encode(e *jx.Encoder) { e.ObjStart() @@ -31882,19 +35151,46 @@ func (s *Price) Encode(e *jx.Encoder) { // encodeFields encodes fields. func (s *Price) encodeFields(e *jx.Encoder) { + { + e.FieldStart("currency_type") + s.CurrencyType.Encode(e) + } { e.FieldStart("value") e.Str(s.Value) } + { + e.FieldStart("decimals") + e.Int(s.Decimals) + } { e.FieldStart("token_name") e.Str(s.TokenName) } + { + e.FieldStart("verification") + s.Verification.Encode(e) + } + { + e.FieldStart("image") + e.Str(s.Image) + } + { + if s.Jetton.Set { + e.FieldStart("jetton") + s.Jetton.Encode(e) + } + } } -var jsonFieldsNameOfPrice = [2]string{ - 0: "value", - 1: "token_name", +var jsonFieldsNameOfPrice = [7]string{ + 0: "currency_type", + 1: "value", + 2: "decimals", + 3: "token_name", + 4: "verification", + 5: "image", + 6: "jetton", } // Decode decodes Price from json. @@ -31906,8 +35202,18 @@ func (s *Price) Decode(d *jx.Decoder) error { if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "value": + case "currency_type": requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.CurrencyType.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"currency_type\"") + } + case "value": + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() s.Value = string(v) @@ -31918,8 +35224,20 @@ func (s *Price) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"value\"") } + case "decimals": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.Decimals = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"decimals\"") + } case "token_name": - requiredBitSet[0] |= 1 << 1 + requiredBitSet[0] |= 1 << 3 if err := func() error { v, err := d.Str() s.TokenName = string(v) @@ -31930,6 +35248,38 @@ func (s *Price) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"token_name\"") } + case "verification": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + if err := s.Verification.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"verification\"") + } + case "image": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Str() + s.Image = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"image\"") + } + case "jetton": + if err := func() error { + s.Jetton.Reset() + if err := s.Jetton.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"jetton\"") + } default: return d.Skip() } @@ -31940,7 +35290,7 @@ func (s *Price) Decode(d *jx.Decoder) error { // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000011, + 0b00111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -31987,49 +35337,68 @@ func (s *Price) UnmarshalJSON(data []byte) error { } // Encode implements json.Marshaler. -func (s *RawBlockchainConfig) Encode(e *jx.Encoder) { +func (s *Protocol) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *RawBlockchainConfig) encodeFields(e *jx.Encoder) { +func (s *Protocol) encodeFields(e *jx.Encoder) { { - e.FieldStart("config") - s.Config.Encode(e) + e.FieldStart("name") + e.Str(s.Name) + } + { + if s.Image.Set { + e.FieldStart("image") + s.Image.Encode(e) + } } } -var jsonFieldsNameOfRawBlockchainConfig = [1]string{ - 0: "config", +var jsonFieldsNameOfProtocol = [2]string{ + 0: "name", + 1: "image", } -// Decode decodes RawBlockchainConfig from json. -func (s *RawBlockchainConfig) Decode(d *jx.Decoder) error { +// Decode decodes Protocol from json. +func (s *Protocol) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode RawBlockchainConfig to nil") + return errors.New("invalid: unable to decode Protocol to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "config": + case "name": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Config.Decode(d); err != nil { + v, err := d.Str() + s.Name = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"config\"") + return errors.Wrap(err, "decode field \"name\"") + } + case "image": + if err := func() error { + s.Image.Reset() + if err := s.Image.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"image\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode RawBlockchainConfig") + return errors.Wrap(err, "decode Protocol") } // Validate required fields. var failures []validate.FieldError @@ -32046,8 +35415,8 @@ func (s *RawBlockchainConfig) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfRawBlockchainConfig) { - name = jsonFieldsNameOfRawBlockchainConfig[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfProtocol) { + name = jsonFieldsNameOfProtocol[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -32068,206 +35437,136 @@ func (s *RawBlockchainConfig) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *RawBlockchainConfig) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *RawBlockchainConfig) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s RawBlockchainConfigConfig) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields implements json.Marshaler. -func (s RawBlockchainConfigConfig) encodeFields(e *jx.Encoder) { - for k, elem := range s { - e.FieldStart(k) - - if len(elem) != 0 { - e.Raw(elem) - } - } -} - -// Decode decodes RawBlockchainConfigConfig from json. -func (s *RawBlockchainConfigConfig) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode RawBlockchainConfigConfig to nil") - } - m := s.init() - if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - var elem jx.Raw - if err := func() error { - v, err := d.RawAppend(nil) - elem = jx.Raw(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrapf(err, "decode field %q", k) - } - m[string(k)] = elem - return nil - }); err != nil { - return errors.Wrap(err, "decode RawBlockchainConfigConfig") - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s RawBlockchainConfigConfig) MarshalJSON() ([]byte, error) { +func (s *Protocol) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *RawBlockchainConfigConfig) UnmarshalJSON(data []byte) error { +func (s *Protocol) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ReducedBlock) Encode(e *jx.Encoder) { +func (s *Purchase) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ReducedBlock) encodeFields(e *jx.Encoder) { +func (s *Purchase) encodeFields(e *jx.Encoder) { { - e.FieldStart("workchain_id") - e.Int32(s.WorkchainID) + e.FieldStart("event_id") + e.Str(s.EventID) } { - e.FieldStart("shard") - e.Str(s.Shard) + e.FieldStart("invoice_id") + e.Str(s.InvoiceID) } { - e.FieldStart("seqno") - e.Int32(s.Seqno) + e.FieldStart("source") + s.Source.Encode(e) } { - if s.MasterRef.Set { - e.FieldStart("master_ref") - s.MasterRef.Encode(e) - } + e.FieldStart("destination") + s.Destination.Encode(e) } { - e.FieldStart("tx_quantity") - e.Int(s.TxQuantity) + e.FieldStart("lt") + e.Int64(s.Lt) } { e.FieldStart("utime") e.Int64(s.Utime) } { - e.FieldStart("shards_blocks") - e.ArrStart() - for _, elem := range s.ShardsBlocks { - e.Str(elem) - } - e.ArrEnd() + e.FieldStart("amount") + s.Amount.Encode(e) } { - e.FieldStart("parent") - e.ArrStart() - for _, elem := range s.Parent { - e.Str(elem) - } - e.ArrEnd() + e.FieldStart("metadata") + s.Metadata.Encode(e) } } -var jsonFieldsNameOfReducedBlock = [8]string{ - 0: "workchain_id", - 1: "shard", - 2: "seqno", - 3: "master_ref", - 4: "tx_quantity", +var jsonFieldsNameOfPurchase = [8]string{ + 0: "event_id", + 1: "invoice_id", + 2: "source", + 3: "destination", + 4: "lt", 5: "utime", - 6: "shards_blocks", - 7: "parent", + 6: "amount", + 7: "metadata", } -// Decode decodes ReducedBlock from json. -func (s *ReducedBlock) Decode(d *jx.Decoder) error { +// Decode decodes Purchase from json. +func (s *Purchase) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ReducedBlock to nil") + return errors.New("invalid: unable to decode Purchase to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "workchain_id": + case "event_id": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int32() - s.WorkchainID = int32(v) + v, err := d.Str() + s.EventID = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"workchain_id\"") + return errors.Wrap(err, "decode field \"event_id\"") } - case "shard": + case "invoice_id": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.Shard = string(v) + s.InvoiceID = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"shard\"") + return errors.Wrap(err, "decode field \"invoice_id\"") } - case "seqno": + case "source": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Int32() - s.Seqno = int32(v) - if err != nil { + if err := s.Source.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"seqno\"") + return errors.Wrap(err, "decode field \"source\"") } - case "master_ref": + case "destination": + requiredBitSet[0] |= 1 << 3 if err := func() error { - s.MasterRef.Reset() - if err := s.MasterRef.Decode(d); err != nil { + if err := s.Destination.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"master_ref\"") + return errors.Wrap(err, "decode field \"destination\"") } - case "tx_quantity": + case "lt": requiredBitSet[0] |= 1 << 4 if err := func() error { - v, err := d.Int() - s.TxQuantity = int(v) + v, err := d.Int64() + s.Lt = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"tx_quantity\"") + return errors.Wrap(err, "decode field \"lt\"") } case "utime": requiredBitSet[0] |= 1 << 5 @@ -32281,57 +35580,37 @@ func (s *ReducedBlock) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"utime\"") } - case "shards_blocks": + case "amount": requiredBitSet[0] |= 1 << 6 if err := func() error { - s.ShardsBlocks = make([]string, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { - return err - } - s.ShardsBlocks = append(s.ShardsBlocks, elem) - return nil - }); err != nil { + if err := s.Amount.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"shards_blocks\"") + return errors.Wrap(err, "decode field \"amount\"") } - case "parent": + case "metadata": requiredBitSet[0] |= 1 << 7 if err := func() error { - s.Parent = make([]string, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { - return err - } - s.Parent = append(s.Parent, elem) - return nil - }); err != nil { + if err := s.Metadata.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"parent\"") + return errors.Wrap(err, "decode field \"metadata\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ReducedBlock") + return errors.Wrap(err, "decode Purchase") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b11110111, + 0b11111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -32343,8 +35622,8 @@ func (s *ReducedBlock) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfReducedBlock) { - name = jsonFieldsNameOfReducedBlock[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfPurchase) { + name = jsonFieldsNameOfPurchase[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -32365,79 +35644,129 @@ func (s *ReducedBlock) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ReducedBlock) MarshalJSON() ([]byte, error) { +func (s *Purchase) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ReducedBlock) UnmarshalJSON(data []byte) error { +func (s *Purchase) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ReducedBlocks) Encode(e *jx.Encoder) { +func (s *PurchaseAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ReducedBlocks) encodeFields(e *jx.Encoder) { +func (s *PurchaseAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("blocks") - e.ArrStart() - for _, elem := range s.Blocks { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("source") + s.Source.Encode(e) + } + { + e.FieldStart("destination") + s.Destination.Encode(e) + } + { + e.FieldStart("invoice_id") + e.Str(s.InvoiceID) + } + { + e.FieldStart("amount") + s.Amount.Encode(e) + } + { + e.FieldStart("metadata") + s.Metadata.Encode(e) } } -var jsonFieldsNameOfReducedBlocks = [1]string{ - 0: "blocks", +var jsonFieldsNameOfPurchaseAction = [5]string{ + 0: "source", + 1: "destination", + 2: "invoice_id", + 3: "amount", + 4: "metadata", } -// Decode decodes ReducedBlocks from json. -func (s *ReducedBlocks) Decode(d *jx.Decoder) error { +// Decode decodes PurchaseAction from json. +func (s *PurchaseAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ReducedBlocks to nil") + return errors.New("invalid: unable to decode PurchaseAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "blocks": + case "source": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Blocks = make([]ReducedBlock, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem ReducedBlock - if err := elem.Decode(d); err != nil { - return err - } - s.Blocks = append(s.Blocks, elem) - return nil - }); err != nil { + if err := s.Source.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"blocks\"") + return errors.Wrap(err, "decode field \"source\"") + } + case "destination": + requiredBitSet[0] |= 1 << 1 + 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 "invoice_id": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.InvoiceID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"invoice_id\"") + } + case "amount": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + if err := s.Amount.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"amount\"") + } + case "metadata": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + if err := s.Metadata.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"metadata\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ReducedBlocks") + return errors.Wrap(err, "decode PurchaseAction") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00011111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -32449,8 +35778,8 @@ func (s *ReducedBlocks) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfReducedBlocks) { - name = jsonFieldsNameOfReducedBlocks[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfPurchaseAction) { + name = jsonFieldsNameOfPurchaseAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -32471,84 +35800,67 @@ func (s *ReducedBlocks) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ReducedBlocks) MarshalJSON() ([]byte, error) { +func (s *PurchaseAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ReducedBlocks) UnmarshalJSON(data []byte) error { +func (s *PurchaseAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Refund) Encode(e *jx.Encoder) { +func (s *RawBlockchainConfig) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Refund) encodeFields(e *jx.Encoder) { - { - e.FieldStart("type") - s.Type.Encode(e) - } +func (s *RawBlockchainConfig) encodeFields(e *jx.Encoder) { { - e.FieldStart("origin") - e.Str(s.Origin) + e.FieldStart("config") + s.Config.Encode(e) } } -var jsonFieldsNameOfRefund = [2]string{ - 0: "type", - 1: "origin", +var jsonFieldsNameOfRawBlockchainConfig = [1]string{ + 0: "config", } -// Decode decodes Refund from json. -func (s *Refund) Decode(d *jx.Decoder) error { +// Decode decodes RawBlockchainConfig from json. +func (s *RawBlockchainConfig) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Refund to nil") + return errors.New("invalid: unable to decode RawBlockchainConfig to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "type": + case "config": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Type.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"type\"") - } - case "origin": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Str() - s.Origin = string(v) - if err != nil { + if err := s.Config.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"origin\"") + return errors.Wrap(err, "decode field \"config\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Refund") + return errors.Wrap(err, "decode RawBlockchainConfig") } // 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. @@ -32560,8 +35872,8 @@ func (s *Refund) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfRefund) { - name = jsonFieldsNameOfRefund[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfRawBlockchainConfig) { + name = jsonFieldsNameOfRawBlockchainConfig[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -32582,182 +35894,270 @@ func (s *Refund) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Refund) MarshalJSON() ([]byte, error) { +func (s *RawBlockchainConfig) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Refund) UnmarshalJSON(data []byte) error { +func (s *RawBlockchainConfig) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode encodes RefundType as json. -func (s RefundType) Encode(e *jx.Encoder) { - e.Str(string(s)) +// Encode implements json.Marshaler. +func (s RawBlockchainConfigConfig) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() } -// Decode decodes RefundType from json. -func (s *RefundType) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode RefundType to nil") +// encodeFields implements json.Marshaler. +func (s RawBlockchainConfigConfig) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } } - v, err := d.StrBytes() - if err != nil { - return err +} + +// Decode decodes RawBlockchainConfigConfig from json. +func (s *RawBlockchainConfigConfig) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode RawBlockchainConfigConfig to nil") } - // Try to use constant string. - switch RefundType(v) { - case RefundTypeDNSTon: - *s = RefundTypeDNSTon - case RefundTypeDNSTg: - *s = RefundTypeDNSTg - case RefundTypeGetGems: - *s = RefundTypeGetGems - default: - *s = RefundType(v) + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + elem = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode RawBlockchainConfigConfig") } return nil } // MarshalJSON implements stdjson.Marshaler. -func (s RefundType) MarshalJSON() ([]byte, error) { +func (s RawBlockchainConfigConfig) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *RefundType) UnmarshalJSON(data []byte) error { +func (s *RawBlockchainConfigConfig) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Risk) Encode(e *jx.Encoder) { +func (s *ReducedBlock) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Risk) encodeFields(e *jx.Encoder) { +func (s *ReducedBlock) encodeFields(e *jx.Encoder) { { - e.FieldStart("transfer_all_remaining_balance") - e.Bool(s.TransferAllRemainingBalance) + e.FieldStart("workchain_id") + e.Int32(s.WorkchainID) } { - e.FieldStart("ton") - e.Int64(s.Ton) + e.FieldStart("shard") + e.Str(s.Shard) } { - e.FieldStart("jettons") + e.FieldStart("seqno") + e.Int32(s.Seqno) + } + { + if s.MasterRef.Set { + e.FieldStart("master_ref") + s.MasterRef.Encode(e) + } + } + { + e.FieldStart("tx_quantity") + e.Int(s.TxQuantity) + } + { + e.FieldStart("utime") + e.Int64(s.Utime) + } + { + e.FieldStart("shards_blocks") e.ArrStart() - for _, elem := range s.Jettons { - elem.Encode(e) + for _, elem := range s.ShardsBlocks { + e.Str(elem) } e.ArrEnd() } { - e.FieldStart("nfts") + e.FieldStart("parent") e.ArrStart() - for _, elem := range s.Nfts { - elem.Encode(e) + for _, elem := range s.Parent { + e.Str(elem) } e.ArrEnd() } } -var jsonFieldsNameOfRisk = [4]string{ - 0: "transfer_all_remaining_balance", - 1: "ton", - 2: "jettons", - 3: "nfts", +var jsonFieldsNameOfReducedBlock = [8]string{ + 0: "workchain_id", + 1: "shard", + 2: "seqno", + 3: "master_ref", + 4: "tx_quantity", + 5: "utime", + 6: "shards_blocks", + 7: "parent", } -// Decode decodes Risk from json. -func (s *Risk) Decode(d *jx.Decoder) error { +// Decode decodes ReducedBlock from json. +func (s *ReducedBlock) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Risk to nil") + return errors.New("invalid: unable to decode ReducedBlock to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "transfer_all_remaining_balance": + case "workchain_id": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Bool() - s.TransferAllRemainingBalance = bool(v) + v, err := d.Int32() + s.WorkchainID = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"transfer_all_remaining_balance\"") + return errors.Wrap(err, "decode field \"workchain_id\"") } - case "ton": + case "shard": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int64() - s.Ton = int64(v) + v, err := d.Str() + s.Shard = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ton\"") + return errors.Wrap(err, "decode field \"shard\"") } - case "jettons": + case "seqno": requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Jettons = make([]JettonQuantity, 0) + v, err := d.Int32() + s.Seqno = int32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"seqno\"") + } + case "master_ref": + if err := func() error { + s.MasterRef.Reset() + if err := s.MasterRef.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"master_ref\"") + } + case "tx_quantity": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int() + s.TxQuantity = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tx_quantity\"") + } + case "utime": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Int64() + s.Utime = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"utime\"") + } + case "shards_blocks": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + s.ShardsBlocks = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem JettonQuantity - if err := elem.Decode(d); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } - s.Jettons = append(s.Jettons, elem) + s.ShardsBlocks = append(s.ShardsBlocks, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"jettons\"") + return errors.Wrap(err, "decode field \"shards_blocks\"") } - case "nfts": - requiredBitSet[0] |= 1 << 3 + case "parent": + requiredBitSet[0] |= 1 << 7 if err := func() error { - s.Nfts = make([]NftItem, 0) + s.Parent = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem NftItem - if err := elem.Decode(d); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } - s.Nfts = append(s.Nfts, elem) + s.Parent = append(s.Parent, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"nfts\"") + return errors.Wrap(err, "decode field \"parent\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Risk") + return errors.Wrap(err, "decode ReducedBlock") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001111, + 0b11110111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -32769,8 +36169,8 @@ func (s *Risk) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfRisk) { - name = jsonFieldsNameOfRisk[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfReducedBlock) { + name = jsonFieldsNameOfReducedBlock[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -32791,116 +36191,79 @@ func (s *Risk) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Risk) MarshalJSON() ([]byte, error) { +func (s *ReducedBlock) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Risk) UnmarshalJSON(data []byte) error { +func (s *ReducedBlock) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Sale) Encode(e *jx.Encoder) { +func (s *ReducedBlocks) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Sale) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } - { - e.FieldStart("market") - s.Market.Encode(e) - } +func (s *ReducedBlocks) encodeFields(e *jx.Encoder) { { - if s.Owner.Set { - e.FieldStart("owner") - s.Owner.Encode(e) + e.FieldStart("blocks") + e.ArrStart() + for _, elem := range s.Blocks { + elem.Encode(e) } - } - { - e.FieldStart("price") - s.Price.Encode(e) + e.ArrEnd() } } -var jsonFieldsNameOfSale = [4]string{ - 0: "address", - 1: "market", - 2: "owner", - 3: "price", +var jsonFieldsNameOfReducedBlocks = [1]string{ + 0: "blocks", } -// Decode decodes Sale from json. -func (s *Sale) Decode(d *jx.Decoder) error { +// Decode decodes ReducedBlocks from json. +func (s *ReducedBlocks) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Sale to nil") + return errors.New("invalid: unable to decode ReducedBlocks to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "blocks": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Address = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") - } - case "market": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - if err := s.Market.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"market\"") - } - case "owner": - if err := func() error { - s.Owner.Reset() - if err := s.Owner.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"owner\"") - } - case "price": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - if err := s.Price.Decode(d); err != nil { + s.Blocks = make([]ReducedBlock, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ReducedBlock + 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 \"price\"") + return errors.Wrap(err, "decode field \"blocks\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Sale") + return errors.Wrap(err, "decode ReducedBlocks") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001011, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -32912,8 +36275,8 @@ func (s *Sale) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfSale) { - name = jsonFieldsNameOfSale[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfReducedBlocks) { + name = jsonFieldsNameOfReducedBlocks[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -32934,162 +36297,84 @@ func (s *Sale) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Sale) MarshalJSON() ([]byte, error) { +func (s *ReducedBlocks) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Sale) UnmarshalJSON(data []byte) error { +func (s *ReducedBlocks) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *SendBlockchainMessageReq) Encode(e *jx.Encoder) { +func (s *Refund) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *SendBlockchainMessageReq) encodeFields(e *jx.Encoder) { +func (s *Refund) encodeFields(e *jx.Encoder) { { - if s.Boc.Set { - e.FieldStart("boc") - s.Boc.Encode(e) - } + e.FieldStart("type") + s.Type.Encode(e) } { - if s.Batch != nil { - e.FieldStart("batch") - e.ArrStart() - for _, elem := range s.Batch { - e.Str(elem) - } - e.ArrEnd() - } + e.FieldStart("origin") + e.Str(s.Origin) } } -var jsonFieldsNameOfSendBlockchainMessageReq = [2]string{ - 0: "boc", - 1: "batch", +var jsonFieldsNameOfRefund = [2]string{ + 0: "type", + 1: "origin", } -// Decode decodes SendBlockchainMessageReq from json. -func (s *SendBlockchainMessageReq) Decode(d *jx.Decoder) error { +// Decode decodes Refund from json. +func (s *Refund) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode SendBlockchainMessageReq to nil") + return errors.New("invalid: unable to decode Refund to nil") } + var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "boc": - if err := func() error { - s.Boc.Reset() - if err := s.Boc.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"boc\"") - } - case "batch": + case "type": + requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Batch = make([]string, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { - return err - } - s.Batch = append(s.Batch, elem) - return nil - }); err != nil { + if err := s.Type.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"batch\"") + return errors.Wrap(err, "decode field \"type\"") } - default: - return d.Skip() - } - return nil - }); err != nil { - return errors.Wrap(err, "decode SendBlockchainMessageReq") - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s *SendBlockchainMessageReq) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *SendBlockchainMessageReq) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s *SendRawMessageOK) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *SendRawMessageOK) encodeFields(e *jx.Encoder) { - { - e.FieldStart("code") - e.Int32(s.Code) - } -} - -var jsonFieldsNameOfSendRawMessageOK = [1]string{ - 0: "code", -} - -// Decode decodes SendRawMessageOK from json. -func (s *SendRawMessageOK) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode SendRawMessageOK 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 + case "origin": + requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int32() - s.Code = int32(v) + v, err := d.Str() + s.Origin = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"code\"") + return errors.Wrap(err, "decode field \"origin\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode SendRawMessageOK") + return errors.Wrap(err, "decode Refund") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -33101,8 +36386,8 @@ func (s *SendRawMessageOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfSendRawMessageOK) { - name = jsonFieldsNameOfSendRawMessageOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfRefund) { + name = jsonFieldsNameOfRefund[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -33123,69 +36408,126 @@ func (s *SendRawMessageOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *SendRawMessageOK) MarshalJSON() ([]byte, error) { +func (s *Refund) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *SendRawMessageOK) UnmarshalJSON(data []byte) error { +func (s *Refund) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes RefundType as json. +func (s RefundType) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes RefundType from json. +func (s *RefundType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode RefundType to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch RefundType(v) { + case RefundTypeDNSTon: + *s = RefundTypeDNSTon + case RefundTypeDNSTg: + *s = RefundTypeDNSTg + case RefundTypeGetGems: + *s = RefundTypeGetGems + default: + *s = RefundType(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s RefundType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *RefundType) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *SendRawMessageReq) Encode(e *jx.Encoder) { +func (s *RemoveExtensionAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *SendRawMessageReq) encodeFields(e *jx.Encoder) { +func (s *RemoveExtensionAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("body") - e.Str(s.Body) + e.FieldStart("wallet") + s.Wallet.Encode(e) + } + { + e.FieldStart("extension") + e.Str(s.Extension) } } -var jsonFieldsNameOfSendRawMessageReq = [1]string{ - 0: "body", +var jsonFieldsNameOfRemoveExtensionAction = [2]string{ + 0: "wallet", + 1: "extension", } -// Decode decodes SendRawMessageReq from json. -func (s *SendRawMessageReq) Decode(d *jx.Decoder) error { +// Decode decodes RemoveExtensionAction from json. +func (s *RemoveExtensionAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode SendRawMessageReq to nil") + return errors.New("invalid: unable to decode RemoveExtensionAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "body": + case "wallet": requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Wallet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet\"") + } + case "extension": + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.Body = string(v) + s.Extension = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"body\"") + return errors.Wrap(err, "decode field \"extension\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode SendRawMessageReq") + return errors.Wrap(err, "decode RemoveExtensionAction") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -33197,8 +36539,8 @@ func (s *SendRawMessageReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfSendRawMessageReq) { - name = jsonFieldsNameOfSendRawMessageReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfRemoveExtensionAction) { + name = jsonFieldsNameOfRemoveExtensionAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -33219,69 +36561,157 @@ func (s *SendRawMessageReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *SendRawMessageReq) MarshalJSON() ([]byte, error) { +func (s *RemoveExtensionAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *SendRawMessageReq) UnmarshalJSON(data []byte) error { +func (s *RemoveExtensionAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Seqno) Encode(e *jx.Encoder) { +func (s *Risk) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Seqno) encodeFields(e *jx.Encoder) { +func (s *Risk) encodeFields(e *jx.Encoder) { { - e.FieldStart("seqno") - e.Int32(s.Seqno) + e.FieldStart("transfer_all_remaining_balance") + e.Bool(s.TransferAllRemainingBalance) + } + { + e.FieldStart("ton") + e.Int64(s.Ton) + } + { + e.FieldStart("jettons") + e.ArrStart() + for _, elem := range s.Jettons { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("nfts") + e.ArrStart() + for _, elem := range s.Nfts { + elem.Encode(e) + } + e.ArrEnd() + } + { + if s.TotalEquivalent.Set { + e.FieldStart("total_equivalent") + s.TotalEquivalent.Encode(e) + } } } -var jsonFieldsNameOfSeqno = [1]string{ - 0: "seqno", +var jsonFieldsNameOfRisk = [5]string{ + 0: "transfer_all_remaining_balance", + 1: "ton", + 2: "jettons", + 3: "nfts", + 4: "total_equivalent", } -// Decode decodes Seqno from json. -func (s *Seqno) Decode(d *jx.Decoder) error { +// Decode decodes Risk from json. +func (s *Risk) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Seqno to nil") + return errors.New("invalid: unable to decode Risk to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "seqno": + case "transfer_all_remaining_balance": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int32() - s.Seqno = int32(v) + v, err := d.Bool() + s.TransferAllRemainingBalance = bool(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"seqno\"") + return errors.Wrap(err, "decode field \"transfer_all_remaining_balance\"") + } + case "ton": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int64() + s.Ton = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ton\"") + } + case "jettons": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + s.Jettons = make([]JettonQuantity, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem JettonQuantity + if err := elem.Decode(d); err != nil { + return err + } + s.Jettons = append(s.Jettons, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"jettons\"") + } + case "nfts": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + s.Nfts = make([]NftItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NftItem + if err := elem.Decode(d); err != nil { + return err + } + s.Nfts = append(s.Nfts, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"nfts\"") + } + case "total_equivalent": + if err := func() error { + s.TotalEquivalent.Reset() + if err := s.TotalEquivalent.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total_equivalent\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Seqno") + return errors.Wrap(err, "decode Risk") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00001111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -33293,8 +36723,8 @@ func (s *Seqno) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfSeqno) { - name = jsonFieldsNameOfSeqno[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfRisk) { + name = jsonFieldsNameOfRisk[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -33315,104 +36745,116 @@ func (s *Seqno) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Seqno) MarshalJSON() ([]byte, error) { +func (s *Risk) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Seqno) UnmarshalJSON(data []byte) error { +func (s *Risk) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ServiceStatus) Encode(e *jx.Encoder) { +func (s *Sale) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ServiceStatus) encodeFields(e *jx.Encoder) { +func (s *Sale) encodeFields(e *jx.Encoder) { { - e.FieldStart("rest_online") - e.Bool(s.RestOnline) + e.FieldStart("address") + e.Str(s.Address) } { - e.FieldStart("indexing_latency") - e.Int(s.IndexingLatency) + e.FieldStart("market") + s.Market.Encode(e) } { - e.FieldStart("last_known_masterchain_seqno") - e.Int32(s.LastKnownMasterchainSeqno) + if s.Owner.Set { + e.FieldStart("owner") + s.Owner.Encode(e) + } + } + { + e.FieldStart("price") + s.Price.Encode(e) } } -var jsonFieldsNameOfServiceStatus = [3]string{ - 0: "rest_online", - 1: "indexing_latency", - 2: "last_known_masterchain_seqno", +var jsonFieldsNameOfSale = [4]string{ + 0: "address", + 1: "market", + 2: "owner", + 3: "price", } -// Decode decodes ServiceStatus from json. -func (s *ServiceStatus) Decode(d *jx.Decoder) error { +// Decode decodes Sale from json. +func (s *Sale) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ServiceStatus to nil") + return errors.New("invalid: unable to decode Sale to nil") } var requiredBitSet [1]uint8 - s.setDefaults() if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "rest_online": + case "address": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Bool() - s.RestOnline = bool(v) + v, err := d.Str() + s.Address = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"rest_online\"") + return errors.Wrap(err, "decode field \"address\"") } - case "indexing_latency": + case "market": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int() - s.IndexingLatency = int(v) - if err != nil { + if err := s.Market.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"indexing_latency\"") + return errors.Wrap(err, "decode field \"market\"") } - case "last_known_masterchain_seqno": - requiredBitSet[0] |= 1 << 2 + case "owner": if err := func() error { - v, err := d.Int32() - s.LastKnownMasterchainSeqno = int32(v) - if err != nil { + s.Owner.Reset() + if err := s.Owner.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"last_known_masterchain_seqno\"") + return errors.Wrap(err, "decode field \"owner\"") + } + case "price": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + if err := s.Price.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"price\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ServiceStatus") + return errors.Wrap(err, "decode Sale") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b00001011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -33424,8 +36866,8 @@ func (s *ServiceStatus) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfServiceStatus) { - name = jsonFieldsNameOfServiceStatus[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSale) { + name = jsonFieldsNameOfSale[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -33446,120 +36888,235 @@ func (s *ServiceStatus) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ServiceStatus) MarshalJSON() ([]byte, error) { +func (s *Sale) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ServiceStatus) UnmarshalJSON(data []byte) error { +func (s *Sale) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *SignRawMessage) Encode(e *jx.Encoder) { +func (s *SendBlockchainMessageReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *SignRawMessage) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } +func (s *SendBlockchainMessageReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("amount") - e.Str(s.Amount) + if s.Boc.Set { + e.FieldStart("boc") + s.Boc.Encode(e) + } } { - if s.Payload.Set { - e.FieldStart("payload") - s.Payload.Encode(e) + if s.Batch != nil { + e.FieldStart("batch") + e.ArrStart() + for _, elem := range s.Batch { + e.Str(elem) + } + e.ArrEnd() } } { - if s.StateInit.Set { - e.FieldStart("stateInit") - s.StateInit.Encode(e) + if s.Meta.Set { + e.FieldStart("meta") + s.Meta.Encode(e) } } } -var jsonFieldsNameOfSignRawMessage = [4]string{ - 0: "address", - 1: "amount", - 2: "payload", - 3: "stateInit", +var jsonFieldsNameOfSendBlockchainMessageReq = [3]string{ + 0: "boc", + 1: "batch", + 2: "meta", } -// Decode decodes SignRawMessage from json. -func (s *SignRawMessage) Decode(d *jx.Decoder) error { +// Decode decodes SendBlockchainMessageReq from json. +func (s *SendBlockchainMessageReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode SignRawMessage to nil") + return errors.New("invalid: unable to decode SendBlockchainMessageReq to nil") } - var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": - requiredBitSet[0] |= 1 << 0 + case "boc": if err := func() error { - v, err := d.Str() - s.Address = string(v) - if err != nil { + s.Boc.Reset() + if err := s.Boc.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") + return errors.Wrap(err, "decode field \"boc\"") } - case "amount": - requiredBitSet[0] |= 1 << 1 + case "batch": if err := func() error { - v, err := d.Str() - s.Amount = string(v) - if err != nil { + s.Batch = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Batch = append(s.Batch, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") + return errors.Wrap(err, "decode field \"batch\"") } - case "payload": + case "meta": if err := func() error { - s.Payload.Reset() - if err := s.Payload.Decode(d); err != nil { + s.Meta.Reset() + if err := s.Meta.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"payload\"") + return errors.Wrap(err, "decode field \"meta\"") } - case "stateInit": + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode SendBlockchainMessageReq") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *SendBlockchainMessageReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *SendBlockchainMessageReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s SendBlockchainMessageReqMeta) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s SendBlockchainMessageReqMeta) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + e.Str(elem) + } +} + +// Decode decodes SendBlockchainMessageReqMeta from json. +func (s *SendBlockchainMessageReqMeta) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode SendBlockchainMessageReqMeta to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem string + if err := func() error { + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode SendBlockchainMessageReqMeta") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s SendBlockchainMessageReqMeta) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *SendBlockchainMessageReqMeta) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *SendRawMessageOK) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *SendRawMessageOK) encodeFields(e *jx.Encoder) { + { + e.FieldStart("code") + e.Int32(s.Code) + } +} + +var jsonFieldsNameOfSendRawMessageOK = [1]string{ + 0: "code", +} + +// Decode decodes SendRawMessageOK from json. +func (s *SendRawMessageOK) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode SendRawMessageOK 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 { - s.StateInit.Reset() - if err := s.StateInit.Decode(d); err != nil { + v, err := d.Int32() + s.Code = int32(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"stateInit\"") + return errors.Wrap(err, "decode field \"code\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode SignRawMessage") + return errors.Wrap(err, "decode SendRawMessageOK") } // 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. @@ -33571,8 +37128,8 @@ func (s *SignRawMessage) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfSignRawMessage) { - name = jsonFieldsNameOfSignRawMessage[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSendRawMessageOK) { + name = jsonFieldsNameOfSendRawMessageOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -33593,147 +37150,69 @@ func (s *SignRawMessage) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *SignRawMessage) MarshalJSON() ([]byte, error) { +func (s *SendRawMessageOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *SignRawMessage) UnmarshalJSON(data []byte) error { +func (s *SendRawMessageOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *SignRawParams) Encode(e *jx.Encoder) { +func (s *SendRawMessageReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *SignRawParams) encodeFields(e *jx.Encoder) { - { - e.FieldStart("relay_address") - e.Str(s.RelayAddress) - } - { - e.FieldStart("commission") - e.Str(s.Commission) - } - { - e.FieldStart("from") - e.Str(s.From) - } - { - e.FieldStart("valid_until") - e.Int64(s.ValidUntil) - } +func (s *SendRawMessageReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("messages") - e.ArrStart() - for _, elem := range s.Messages { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("body") + e.Str(s.Body) } } -var jsonFieldsNameOfSignRawParams = [5]string{ - 0: "relay_address", - 1: "commission", - 2: "from", - 3: "valid_until", - 4: "messages", +var jsonFieldsNameOfSendRawMessageReq = [1]string{ + 0: "body", } -// Decode decodes SignRawParams from json. -func (s *SignRawParams) Decode(d *jx.Decoder) error { +// Decode decodes SendRawMessageReq from json. +func (s *SendRawMessageReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode SignRawParams to nil") + return errors.New("invalid: unable to decode SendRawMessageReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "relay_address": + case "body": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.RelayAddress = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"relay_address\"") - } - case "commission": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Str() - s.Commission = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"commission\"") - } - case "from": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Str() - s.From = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"from\"") - } - case "valid_until": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Int64() - s.ValidUntil = int64(v) + s.Body = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"valid_until\"") - } - case "messages": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - s.Messages = make([]SignRawMessage, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem SignRawMessage - if err := elem.Decode(d); err != nil { - return err - } - s.Messages = append(s.Messages, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"messages\"") + return errors.Wrap(err, "decode field \"body\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode SignRawParams") + return errors.Wrap(err, "decode SendRawMessageReq") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00011111, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -33745,8 +37224,8 @@ func (s *SignRawParams) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfSignRawParams) { - name = jsonFieldsNameOfSignRawParams[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSendRawMessageReq) { + name = jsonFieldsNameOfSendRawMessageReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -33767,188 +37246,69 @@ func (s *SignRawParams) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *SignRawParams) MarshalJSON() ([]byte, error) { +func (s *SendRawMessageReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *SignRawParams) UnmarshalJSON(data []byte) error { +func (s *SendRawMessageReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *SizeLimitsConfig) Encode(e *jx.Encoder) { +func (s *Seqno) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *SizeLimitsConfig) encodeFields(e *jx.Encoder) { +func (s *Seqno) encodeFields(e *jx.Encoder) { { - e.FieldStart("max_msg_bits") - e.Int64(s.MaxMsgBits) - } - { - e.FieldStart("max_msg_cells") - e.Int64(s.MaxMsgCells) - } - { - e.FieldStart("max_library_cells") - e.Int64(s.MaxLibraryCells) - } - { - e.FieldStart("max_vm_data_depth") - e.Int(s.MaxVMDataDepth) - } - { - e.FieldStart("max_ext_msg_size") - e.Int64(s.MaxExtMsgSize) - } - { - e.FieldStart("max_ext_msg_depth") - e.Int(s.MaxExtMsgDepth) - } - { - if s.MaxAccStateCells.Set { - e.FieldStart("max_acc_state_cells") - s.MaxAccStateCells.Encode(e) - } - } - { - if s.MaxAccStateBits.Set { - e.FieldStart("max_acc_state_bits") - s.MaxAccStateBits.Encode(e) - } + e.FieldStart("seqno") + e.Int32(s.Seqno) } } -var jsonFieldsNameOfSizeLimitsConfig = [8]string{ - 0: "max_msg_bits", - 1: "max_msg_cells", - 2: "max_library_cells", - 3: "max_vm_data_depth", - 4: "max_ext_msg_size", - 5: "max_ext_msg_depth", - 6: "max_acc_state_cells", - 7: "max_acc_state_bits", +var jsonFieldsNameOfSeqno = [1]string{ + 0: "seqno", } -// Decode decodes SizeLimitsConfig from json. -func (s *SizeLimitsConfig) Decode(d *jx.Decoder) error { +// Decode decodes Seqno from json. +func (s *Seqno) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode SizeLimitsConfig to nil") + return errors.New("invalid: unable to decode Seqno to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "max_msg_bits": + case "seqno": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.MaxMsgBits = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"max_msg_bits\"") - } - case "max_msg_cells": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Int64() - s.MaxMsgCells = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"max_msg_cells\"") - } - case "max_library_cells": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Int64() - s.MaxLibraryCells = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"max_library_cells\"") - } - case "max_vm_data_depth": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Int() - s.MaxVMDataDepth = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"max_vm_data_depth\"") - } - case "max_ext_msg_size": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Int64() - s.MaxExtMsgSize = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"max_ext_msg_size\"") - } - case "max_ext_msg_depth": - requiredBitSet[0] |= 1 << 5 - if err := func() error { - v, err := d.Int() - s.MaxExtMsgDepth = int(v) + v, err := d.Int32() + s.Seqno = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"max_ext_msg_depth\"") - } - case "max_acc_state_cells": - if err := func() error { - s.MaxAccStateCells.Reset() - if err := s.MaxAccStateCells.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"max_acc_state_cells\"") - } - case "max_acc_state_bits": - if err := func() error { - s.MaxAccStateBits.Reset() - if err := s.MaxAccStateBits.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"max_acc_state_bits\"") + return errors.Wrap(err, "decode field \"seqno\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode SizeLimitsConfig") + return errors.Wrap(err, "decode Seqno") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00111111, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -33960,8 +37320,8 @@ func (s *SizeLimitsConfig) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfSizeLimitsConfig) { - name = jsonFieldsNameOfSizeLimitsConfig[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSeqno) { + name = jsonFieldsNameOfSeqno[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -33982,150 +37342,104 @@ func (s *SizeLimitsConfig) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *SizeLimitsConfig) MarshalJSON() ([]byte, error) { +func (s *Seqno) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *SizeLimitsConfig) UnmarshalJSON(data []byte) error { +func (s *Seqno) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *SmartContractAction) Encode(e *jx.Encoder) { +func (s *ServiceStatus) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *SmartContractAction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("executor") - s.Executor.Encode(e) - } - { - e.FieldStart("contract") - s.Contract.Encode(e) - } - { - e.FieldStart("ton_attached") - e.Int64(s.TonAttached) - } +func (s *ServiceStatus) encodeFields(e *jx.Encoder) { { - e.FieldStart("operation") - e.Str(s.Operation) + e.FieldStart("rest_online") + e.Bool(s.RestOnline) } { - if s.Payload.Set { - e.FieldStart("payload") - s.Payload.Encode(e) - } + e.FieldStart("indexing_latency") + e.Int(s.IndexingLatency) } { - if s.Refund.Set { - e.FieldStart("refund") - s.Refund.Encode(e) - } + e.FieldStart("last_known_masterchain_seqno") + e.Int32(s.LastKnownMasterchainSeqno) } } -var jsonFieldsNameOfSmartContractAction = [6]string{ - 0: "executor", - 1: "contract", - 2: "ton_attached", - 3: "operation", - 4: "payload", - 5: "refund", +var jsonFieldsNameOfServiceStatus = [3]string{ + 0: "rest_online", + 1: "indexing_latency", + 2: "last_known_masterchain_seqno", } -// Decode decodes SmartContractAction from json. -func (s *SmartContractAction) Decode(d *jx.Decoder) error { +// Decode decodes ServiceStatus from json. +func (s *ServiceStatus) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode SmartContractAction to nil") + return errors.New("invalid: unable to decode ServiceStatus to nil") } var requiredBitSet [1]uint8 + s.setDefaults() if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "executor": + case "rest_online": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Executor.Decode(d); err != nil { + v, err := d.Bool() + s.RestOnline = bool(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"executor\"") + return errors.Wrap(err, "decode field \"rest_online\"") } - case "contract": + case "indexing_latency": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Contract.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"contract\"") - } - case "ton_attached": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Int64() - s.TonAttached = int64(v) + v, err := d.Int() + s.IndexingLatency = int(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ton_attached\"") + return errors.Wrap(err, "decode field \"indexing_latency\"") } - case "operation": - requiredBitSet[0] |= 1 << 3 + case "last_known_masterchain_seqno": + requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Str() - s.Operation = string(v) + v, err := d.Int32() + s.LastKnownMasterchainSeqno = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"operation\"") - } - case "payload": - if err := func() error { - s.Payload.Reset() - if err := s.Payload.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"payload\"") - } - case "refund": - if err := func() error { - s.Refund.Reset() - if err := s.Refund.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"refund\"") + return errors.Wrap(err, "decode field \"last_known_masterchain_seqno\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode SmartContractAction") + return errors.Wrap(err, "decode ServiceStatus") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001111, + 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -34137,8 +37451,8 @@ func (s *SmartContractAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfSmartContractAction) { - name = jsonFieldsNameOfSmartContractAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfServiceStatus) { + name = jsonFieldsNameOfServiceStatus[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -34159,93 +37473,79 @@ func (s *SmartContractAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *SmartContractAction) MarshalJSON() ([]byte, error) { +func (s *ServiceStatus) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *SmartContractAction) UnmarshalJSON(data []byte) error { +func (s *ServiceStatus) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *StateInit) Encode(e *jx.Encoder) { +func (s *SetSignatureAllowedAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *StateInit) encodeFields(e *jx.Encoder) { +func (s *SetSignatureAllowedAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("boc") - e.Str(s.Boc) + e.FieldStart("wallet") + s.Wallet.Encode(e) } { - e.FieldStart("interfaces") - e.ArrStart() - for _, elem := range s.Interfaces { - e.Str(elem) - } - e.ArrEnd() + e.FieldStart("allowed") + e.Bool(s.Allowed) } } -var jsonFieldsNameOfStateInit = [2]string{ - 0: "boc", - 1: "interfaces", +var jsonFieldsNameOfSetSignatureAllowedAction = [2]string{ + 0: "wallet", + 1: "allowed", } -// Decode decodes StateInit from json. -func (s *StateInit) Decode(d *jx.Decoder) error { +// Decode decodes SetSignatureAllowedAction from json. +func (s *SetSignatureAllowedAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode StateInit to nil") + return errors.New("invalid: unable to decode SetSignatureAllowedAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "boc": + case "wallet": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Boc = string(v) - if err != nil { + if err := s.Wallet.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"boc\"") + return errors.Wrap(err, "decode field \"wallet\"") } - case "interfaces": + case "allowed": requiredBitSet[0] |= 1 << 1 if err := func() error { - s.Interfaces = make([]string, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { - return err - } - s.Interfaces = append(s.Interfaces, elem) - return nil - }); err != nil { + v, err := d.Bool() + s.Allowed = bool(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"interfaces\"") + return errors.Wrap(err, "decode field \"allowed\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode StateInit") + return errors.Wrap(err, "decode SetSignatureAllowedAction") } // Validate required fields. var failures []validate.FieldError @@ -34262,8 +37562,8 @@ func (s *StateInit) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfStateInit) { - name = jsonFieldsNameOfStateInit[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSetSignatureAllowedAction) { + name = jsonFieldsNameOfSetSignatureAllowedAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -34284,101 +37584,120 @@ func (s *StateInit) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *StateInit) MarshalJSON() ([]byte, error) { +func (s *SetSignatureAllowedAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *StateInit) UnmarshalJSON(data []byte) error { +func (s *SetSignatureAllowedAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *StoragePhase) Encode(e *jx.Encoder) { +func (s *SignRawMessage) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *StoragePhase) encodeFields(e *jx.Encoder) { +func (s *SignRawMessage) encodeFields(e *jx.Encoder) { { - e.FieldStart("fees_collected") - e.Int64(s.FeesCollected) + e.FieldStart("address") + e.Str(s.Address) } { - if s.FeesDue.Set { - e.FieldStart("fees_due") - s.FeesDue.Encode(e) + e.FieldStart("amount") + e.Str(s.Amount) + } + { + if s.Payload.Set { + e.FieldStart("payload") + s.Payload.Encode(e) } } { - e.FieldStart("status_change") - s.StatusChange.Encode(e) + if s.StateInit.Set { + e.FieldStart("stateInit") + s.StateInit.Encode(e) + } } } -var jsonFieldsNameOfStoragePhase = [3]string{ - 0: "fees_collected", - 1: "fees_due", - 2: "status_change", +var jsonFieldsNameOfSignRawMessage = [4]string{ + 0: "address", + 1: "amount", + 2: "payload", + 3: "stateInit", } -// Decode decodes StoragePhase from json. -func (s *StoragePhase) Decode(d *jx.Decoder) error { +// Decode decodes SignRawMessage from json. +func (s *SignRawMessage) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode StoragePhase to nil") + return errors.New("invalid: unable to decode SignRawMessage to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "fees_collected": + case "address": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.FeesCollected = int64(v) + v, err := d.Str() + s.Address = 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 \"address\"") } - case "fees_due": + case "amount": + requiredBitSet[0] |= 1 << 1 if err := func() error { - s.FeesDue.Reset() - if err := s.FeesDue.Decode(d); err != nil { + v, err := d.Str() + s.Amount = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"fees_due\"") + return errors.Wrap(err, "decode field \"amount\"") } - case "status_change": - requiredBitSet[0] |= 1 << 2 + case "payload": if err := func() error { - if err := s.StatusChange.Decode(d); err != nil { + s.Payload.Reset() + if err := s.Payload.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"status_change\"") + return errors.Wrap(err, "decode field \"payload\"") + } + case "stateInit": + if err := func() error { + s.StateInit.Reset() + if err := s.StateInit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"stateInit\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode StoragePhase") + return errors.Wrap(err, "decode SignRawMessage") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000101, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -34390,8 +37709,8 @@ func (s *StoragePhase) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfStoragePhase) { - name = jsonFieldsNameOfStoragePhase[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSignRawMessage) { + name = jsonFieldsNameOfSignRawMessage[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -34412,149 +37731,176 @@ func (s *StoragePhase) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *StoragePhase) MarshalJSON() ([]byte, error) { +func (s *SignRawMessage) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *StoragePhase) UnmarshalJSON(data []byte) error { +func (s *SignRawMessage) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *StorageProvider) Encode(e *jx.Encoder) { +func (s *SignRawParams) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *StorageProvider) encodeFields(e *jx.Encoder) { +func (s *SignRawParams) encodeFields(e *jx.Encoder) { { - e.FieldStart("address") - e.Str(s.Address) + e.FieldStart("protocol_name") + e.Str(s.ProtocolName) } { - e.FieldStart("accept_new_contracts") - e.Bool(s.AcceptNewContracts) + e.FieldStart("relay_address") + e.Str(s.RelayAddress) } { - e.FieldStart("rate_per_mb_day") - e.Int64(s.RatePerMBDay) + e.FieldStart("commission") + e.Str(s.Commission) } { - e.FieldStart("max_span") - e.Int64(s.MaxSpan) + e.FieldStart("from") + e.Str(s.From) } { - e.FieldStart("minimal_file_size") - e.Int64(s.MinimalFileSize) + e.FieldStart("valid_until") + e.Int64(s.ValidUntil) } { - e.FieldStart("maximal_file_size") - e.Int64(s.MaximalFileSize) + e.FieldStart("messages") + e.ArrStart() + for _, elem := range s.Messages { + elem.Encode(e) + } + e.ArrEnd() + } + { + if s.Emulation.Set { + e.FieldStart("emulation") + s.Emulation.Encode(e) + } } } -var jsonFieldsNameOfStorageProvider = [6]string{ - 0: "address", - 1: "accept_new_contracts", - 2: "rate_per_mb_day", - 3: "max_span", - 4: "minimal_file_size", - 5: "maximal_file_size", +var jsonFieldsNameOfSignRawParams = [7]string{ + 0: "protocol_name", + 1: "relay_address", + 2: "commission", + 3: "from", + 4: "valid_until", + 5: "messages", + 6: "emulation", } -// Decode decodes StorageProvider from json. -func (s *StorageProvider) Decode(d *jx.Decoder) error { +// Decode decodes SignRawParams from json. +func (s *SignRawParams) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode StorageProvider to nil") + return errors.New("invalid: unable to decode SignRawParams to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "protocol_name": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.Address = string(v) + s.ProtocolName = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") + return errors.Wrap(err, "decode field \"protocol_name\"") } - case "accept_new_contracts": + case "relay_address": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Bool() - s.AcceptNewContracts = bool(v) + v, err := d.Str() + s.RelayAddress = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"accept_new_contracts\"") + return errors.Wrap(err, "decode field \"relay_address\"") } - case "rate_per_mb_day": + case "commission": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Int64() - s.RatePerMBDay = int64(v) + v, err := d.Str() + s.Commission = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"rate_per_mb_day\"") + return errors.Wrap(err, "decode field \"commission\"") } - case "max_span": + case "from": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Int64() - s.MaxSpan = int64(v) + v, err := d.Str() + s.From = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"max_span\"") + return errors.Wrap(err, "decode field \"from\"") } - case "minimal_file_size": + case "valid_until": requiredBitSet[0] |= 1 << 4 if err := func() error { v, err := d.Int64() - s.MinimalFileSize = int64(v) + s.ValidUntil = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"minimal_file_size\"") + return errors.Wrap(err, "decode field \"valid_until\"") } - case "maximal_file_size": + case "messages": requiredBitSet[0] |= 1 << 5 if err := func() error { - v, err := d.Int64() - s.MaximalFileSize = int64(v) - if err != nil { + s.Messages = make([]SignRawMessage, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem SignRawMessage + if err := elem.Decode(d); err != nil { + return err + } + s.Messages = append(s.Messages, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"maximal_file_size\"") + return errors.Wrap(err, "decode field \"messages\"") + } + case "emulation": + if err := func() error { + s.Emulation.Reset() + if err := s.Emulation.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"emulation\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode StorageProvider") + return errors.Wrap(err, "decode SignRawParams") } // Validate required fields. var failures []validate.FieldError @@ -34571,8 +37917,8 @@ func (s *StorageProvider) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfStorageProvider) { - name = jsonFieldsNameOfStorageProvider[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSignRawParams) { + name = jsonFieldsNameOfSignRawParams[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -34593,240 +37939,188 @@ func (s *StorageProvider) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *StorageProvider) MarshalJSON() ([]byte, error) { +func (s *SignRawParams) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *StorageProvider) UnmarshalJSON(data []byte) error { +func (s *SignRawParams) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Subscription) Encode(e *jx.Encoder) { +func (s *SizeLimitsConfig) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Subscription) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } - { - e.FieldStart("wallet_address") - e.Str(s.WalletAddress) - } - { - e.FieldStart("beneficiary_address") - e.Str(s.BeneficiaryAddress) - } +func (s *SizeLimitsConfig) encodeFields(e *jx.Encoder) { { - e.FieldStart("amount") - e.Int64(s.Amount) + e.FieldStart("max_msg_bits") + e.Int64(s.MaxMsgBits) } { - e.FieldStart("period") - e.Int64(s.Period) + e.FieldStart("max_msg_cells") + e.Int64(s.MaxMsgCells) } { - e.FieldStart("start_time") - e.Int64(s.StartTime) + e.FieldStart("max_library_cells") + e.Int64(s.MaxLibraryCells) } { - e.FieldStart("timeout") - e.Int64(s.Timeout) + e.FieldStart("max_vm_data_depth") + e.Int(s.MaxVMDataDepth) } { - e.FieldStart("last_payment_time") - e.Int64(s.LastPaymentTime) + e.FieldStart("max_ext_msg_size") + e.Int64(s.MaxExtMsgSize) } { - e.FieldStart("last_request_time") - e.Int64(s.LastRequestTime) + e.FieldStart("max_ext_msg_depth") + e.Int(s.MaxExtMsgDepth) } { - e.FieldStart("subscription_id") - e.Int64(s.SubscriptionID) + if s.MaxAccStateCells.Set { + e.FieldStart("max_acc_state_cells") + s.MaxAccStateCells.Encode(e) + } } { - e.FieldStart("failed_attempts") - e.Int32(s.FailedAttempts) + if s.MaxAccStateBits.Set { + e.FieldStart("max_acc_state_bits") + s.MaxAccStateBits.Encode(e) + } } } -var jsonFieldsNameOfSubscription = [11]string{ - 0: "address", - 1: "wallet_address", - 2: "beneficiary_address", - 3: "amount", - 4: "period", - 5: "start_time", - 6: "timeout", - 7: "last_payment_time", - 8: "last_request_time", - 9: "subscription_id", - 10: "failed_attempts", +var jsonFieldsNameOfSizeLimitsConfig = [8]string{ + 0: "max_msg_bits", + 1: "max_msg_cells", + 2: "max_library_cells", + 3: "max_vm_data_depth", + 4: "max_ext_msg_size", + 5: "max_ext_msg_depth", + 6: "max_acc_state_cells", + 7: "max_acc_state_bits", } -// Decode decodes Subscription from json. -func (s *Subscription) Decode(d *jx.Decoder) error { +// Decode decodes SizeLimitsConfig from json. +func (s *SizeLimitsConfig) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Subscription to nil") + return errors.New("invalid: unable to decode SizeLimitsConfig to nil") } - var requiredBitSet [2]uint8 + var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "max_msg_bits": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Address = string(v) + v, err := d.Int64() + s.MaxMsgBits = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") + return errors.Wrap(err, "decode field \"max_msg_bits\"") } - case "wallet_address": + case "max_msg_cells": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.WalletAddress = string(v) + v, err := d.Int64() + s.MaxMsgCells = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"wallet_address\"") + return errors.Wrap(err, "decode field \"max_msg_cells\"") } - case "beneficiary_address": + case "max_library_cells": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Str() - s.BeneficiaryAddress = string(v) + v, err := d.Int64() + s.MaxLibraryCells = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"beneficiary_address\"") + return errors.Wrap(err, "decode field \"max_library_cells\"") } - case "amount": + case "max_vm_data_depth": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Int64() - s.Amount = int64(v) + v, err := d.Int() + s.MaxVMDataDepth = int(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") + return errors.Wrap(err, "decode field \"max_vm_data_depth\"") } - case "period": + case "max_ext_msg_size": requiredBitSet[0] |= 1 << 4 if err := func() error { v, err := d.Int64() - s.Period = int64(v) + s.MaxExtMsgSize = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"period\"") + return errors.Wrap(err, "decode field \"max_ext_msg_size\"") } - case "start_time": + case "max_ext_msg_depth": requiredBitSet[0] |= 1 << 5 if err := func() error { - v, err := d.Int64() - s.StartTime = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"start_time\"") - } - case "timeout": - requiredBitSet[0] |= 1 << 6 - if err := func() error { - v, err := d.Int64() - s.Timeout = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"timeout\"") - } - case "last_payment_time": - requiredBitSet[0] |= 1 << 7 - if err := func() error { - v, err := d.Int64() - s.LastPaymentTime = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"last_payment_time\"") - } - case "last_request_time": - requiredBitSet[1] |= 1 << 0 - if err := func() error { - v, err := d.Int64() - s.LastRequestTime = int64(v) + v, err := d.Int() + s.MaxExtMsgDepth = int(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"last_request_time\"") + return errors.Wrap(err, "decode field \"max_ext_msg_depth\"") } - case "subscription_id": - requiredBitSet[1] |= 1 << 1 + case "max_acc_state_cells": if err := func() error { - v, err := d.Int64() - s.SubscriptionID = int64(v) - if err != nil { + s.MaxAccStateCells.Reset() + if err := s.MaxAccStateCells.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"subscription_id\"") + return errors.Wrap(err, "decode field \"max_acc_state_cells\"") } - case "failed_attempts": - requiredBitSet[1] |= 1 << 2 + case "max_acc_state_bits": if err := func() error { - v, err := d.Int32() - s.FailedAttempts = int32(v) - if err != nil { + s.MaxAccStateBits.Reset() + if err := s.MaxAccStateBits.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"failed_attempts\"") + return errors.Wrap(err, "decode field \"max_acc_state_bits\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Subscription") + return errors.Wrap(err, "decode SizeLimitsConfig") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [2]uint8{ - 0b11111111, - 0b00000111, + for i, mask := range [1]uint8{ + 0b00111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -34838,8 +38132,8 @@ func (s *Subscription) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfSubscription) { - name = jsonFieldsNameOfSubscription[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSizeLimitsConfig) { + name = jsonFieldsNameOfSizeLimitsConfig[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -34860,133 +38154,150 @@ func (s *Subscription) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Subscription) MarshalJSON() ([]byte, error) { +func (s *SizeLimitsConfig) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Subscription) UnmarshalJSON(data []byte) error { +func (s *SizeLimitsConfig) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *SubscriptionAction) Encode(e *jx.Encoder) { +func (s *SmartContractAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *SubscriptionAction) encodeFields(e *jx.Encoder) { +func (s *SmartContractAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("subscriber") - s.Subscriber.Encode(e) + e.FieldStart("executor") + s.Executor.Encode(e) } { - e.FieldStart("subscription") - e.Str(s.Subscription) + e.FieldStart("contract") + s.Contract.Encode(e) } { - e.FieldStart("beneficiary") - s.Beneficiary.Encode(e) + e.FieldStart("ton_attached") + e.Int64(s.TonAttached) } { - e.FieldStart("amount") - e.Int64(s.Amount) + e.FieldStart("operation") + e.Str(s.Operation) } { - e.FieldStart("initial") - e.Bool(s.Initial) + if s.Payload.Set { + e.FieldStart("payload") + s.Payload.Encode(e) + } + } + { + if s.Refund.Set { + e.FieldStart("refund") + s.Refund.Encode(e) + } } } -var jsonFieldsNameOfSubscriptionAction = [5]string{ - 0: "subscriber", - 1: "subscription", - 2: "beneficiary", - 3: "amount", - 4: "initial", +var jsonFieldsNameOfSmartContractAction = [6]string{ + 0: "executor", + 1: "contract", + 2: "ton_attached", + 3: "operation", + 4: "payload", + 5: "refund", } -// Decode decodes SubscriptionAction from json. -func (s *SubscriptionAction) Decode(d *jx.Decoder) error { +// Decode decodes SmartContractAction from json. +func (s *SmartContractAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode SubscriptionAction to nil") + return errors.New("invalid: unable to decode SmartContractAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "subscriber": + case "executor": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Subscriber.Decode(d); err != nil { + if err := s.Executor.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"subscriber\"") + return errors.Wrap(err, "decode field \"executor\"") } - case "subscription": + case "contract": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.Subscription = string(v) - if err != nil { + if err := s.Contract.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"subscription\"") + return errors.Wrap(err, "decode field \"contract\"") } - case "beneficiary": + case "ton_attached": requiredBitSet[0] |= 1 << 2 if err := func() error { - if err := s.Beneficiary.Decode(d); err != nil { + v, err := d.Int64() + s.TonAttached = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"beneficiary\"") + return errors.Wrap(err, "decode field \"ton_attached\"") } - case "amount": + case "operation": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Int64() - s.Amount = int64(v) + v, err := d.Str() + s.Operation = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") + return errors.Wrap(err, "decode field \"operation\"") } - case "initial": - requiredBitSet[0] |= 1 << 4 + case "payload": if err := func() error { - v, err := d.Bool() - s.Initial = bool(v) - if err != nil { + s.Payload.Reset() + if err := s.Payload.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"initial\"") + return errors.Wrap(err, "decode field \"payload\"") + } + case "refund": + if err := func() error { + s.Refund.Reset() + if err := s.Refund.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"refund\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode SubscriptionAction") + return errors.Wrap(err, "decode SmartContractAction") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00011111, + 0b00001111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -34998,8 +38309,8 @@ func (s *SubscriptionAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfSubscriptionAction) { - name = jsonFieldsNameOfSubscriptionAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSmartContractAction) { + name = jsonFieldsNameOfSmartContractAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -35020,74 +38331,74 @@ func (s *SubscriptionAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *SubscriptionAction) MarshalJSON() ([]byte, error) { +func (s *SmartContractAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *SubscriptionAction) UnmarshalJSON(data []byte) error { +func (s *SmartContractAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Subscriptions) Encode(e *jx.Encoder) { +func (s *Source) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Subscriptions) encodeFields(e *jx.Encoder) { +func (s *Source) encodeFields(e *jx.Encoder) { { - e.FieldStart("subscriptions") + e.FieldStart("files") e.ArrStart() - for _, elem := range s.Subscriptions { + for _, elem := range s.Files { elem.Encode(e) } e.ArrEnd() } } -var jsonFieldsNameOfSubscriptions = [1]string{ - 0: "subscriptions", +var jsonFieldsNameOfSource = [1]string{ + 0: "files", } -// Decode decodes Subscriptions from json. -func (s *Subscriptions) Decode(d *jx.Decoder) error { +// Decode decodes Source from json. +func (s *Source) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Subscriptions to nil") + return errors.New("invalid: unable to decode Source to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "subscriptions": + case "files": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Subscriptions = make([]Subscription, 0) + s.Files = make([]SourceFile, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem Subscription + var elem SourceFile if err := elem.Decode(d); err != nil { return err } - s.Subscriptions = append(s.Subscriptions, elem) + s.Files = append(s.Files, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"subscriptions\"") + return errors.Wrap(err, "decode field \"files\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Subscriptions") + return errors.Wrap(err, "decode Source") } // Validate required fields. var failures []validate.FieldError @@ -35104,8 +38415,8 @@ func (s *Subscriptions) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfSubscriptions) { - name = jsonFieldsNameOfSubscriptions[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSource) { + name = jsonFieldsNameOfSource[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -35126,407 +38437,390 @@ func (s *Subscriptions) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Subscriptions) MarshalJSON() ([]byte, error) { +func (s *Source) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Subscriptions) UnmarshalJSON(data []byte) error { +func (s *Source) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *TokenRates) Encode(e *jx.Encoder) { +func (s *SourceFile) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *TokenRates) encodeFields(e *jx.Encoder) { +func (s *SourceFile) encodeFields(e *jx.Encoder) { { - if s.Prices.Set { - e.FieldStart("prices") - s.Prices.Encode(e) - } + e.FieldStart("name") + e.Str(s.Name) } { - if s.Diff24h.Set { - e.FieldStart("diff_24h") - s.Diff24h.Encode(e) - } + e.FieldStart("content") + e.Str(s.Content) } { - if s.Diff7d.Set { - e.FieldStart("diff_7d") - s.Diff7d.Encode(e) - } + e.FieldStart("is_entrypoint") + e.Bool(s.IsEntrypoint) } { - if s.Diff30d.Set { - e.FieldStart("diff_30d") - s.Diff30d.Encode(e) - } + e.FieldStart("is_std_lib") + e.Bool(s.IsStdLib) + } + { + e.FieldStart("include_in_command") + e.Bool(s.IncludeInCommand) } } -var jsonFieldsNameOfTokenRates = [4]string{ - 0: "prices", - 1: "diff_24h", - 2: "diff_7d", - 3: "diff_30d", +var jsonFieldsNameOfSourceFile = [5]string{ + 0: "name", + 1: "content", + 2: "is_entrypoint", + 3: "is_std_lib", + 4: "include_in_command", } -// Decode decodes TokenRates from json. -func (s *TokenRates) Decode(d *jx.Decoder) error { +// Decode decodes SourceFile from json. +func (s *SourceFile) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode TokenRates to nil") + return errors.New("invalid: unable to decode SourceFile to nil") } + var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "prices": + case "name": + requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Prices.Reset() - if err := s.Prices.Decode(d); err != nil { + v, err := d.Str() + s.Name = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"prices\"") + return errors.Wrap(err, "decode field \"name\"") } - case "diff_24h": + case "content": + requiredBitSet[0] |= 1 << 1 if err := func() error { - s.Diff24h.Reset() - if err := s.Diff24h.Decode(d); err != nil { + v, err := d.Str() + s.Content = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"diff_24h\"") + return errors.Wrap(err, "decode field \"content\"") } - case "diff_7d": + case "is_entrypoint": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Diff7d.Reset() - if err := s.Diff7d.Decode(d); err != nil { + v, err := d.Bool() + s.IsEntrypoint = bool(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"diff_7d\"") + return errors.Wrap(err, "decode field \"is_entrypoint\"") } - case "diff_30d": + case "is_std_lib": + requiredBitSet[0] |= 1 << 3 if err := func() error { - s.Diff30d.Reset() - if err := s.Diff30d.Decode(d); err != nil { + v, err := d.Bool() + s.IsStdLib = bool(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"diff_30d\"") + return errors.Wrap(err, "decode field \"is_std_lib\"") + } + case "include_in_command": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Bool() + s.IncludeInCommand = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"include_in_command\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode TokenRates") + return errors.Wrap(err, "decode SourceFile") + } + // 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(jsonFieldsNameOfSourceFile) { + name = jsonFieldsNameOfSourceFile[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 *TokenRates) MarshalJSON() ([]byte, error) { +func (s *SourceFile) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TokenRates) UnmarshalJSON(data []byte) error { +func (s *SourceFile) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s TokenRatesDiff24h) Encode(e *jx.Encoder) { +func (s *StateInit) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s TokenRatesDiff24h) encodeFields(e *jx.Encoder) { - for k, elem := range s { - e.FieldStart(k) - - e.Str(elem) +// encodeFields encodes fields. +func (s *StateInit) encodeFields(e *jx.Encoder) { + { + e.FieldStart("boc") + e.Str(s.Boc) + } + { + e.FieldStart("interfaces") + e.ArrStart() + for _, elem := range s.Interfaces { + e.Str(elem) + } + e.ArrEnd() } } -// Decode decodes TokenRatesDiff24h from json. -func (s *TokenRatesDiff24h) Decode(d *jx.Decoder) error { +var jsonFieldsNameOfStateInit = [2]string{ + 0: "boc", + 1: "interfaces", +} + +// Decode decodes StateInit from json. +func (s *StateInit) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode TokenRatesDiff24h to nil") + return errors.New("invalid: unable to decode StateInit to nil") } - m := s.init() + var requiredBitSet [1]uint8 + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - var elem string - if err := func() error { - v, err := d.Str() - elem = string(v) - if err != nil { - return err + 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\"") } - return nil - }(); err != nil { - return errors.Wrapf(err, "decode field %q", k) + case "interfaces": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + s.Interfaces = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Interfaces = append(s.Interfaces, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"interfaces\"") + } + default: + return d.Skip() } - m[string(k)] = elem return nil }); err != nil { - return errors.Wrap(err, "decode TokenRatesDiff24h") + return errors.Wrap(err, "decode StateInit") + } + // 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(jsonFieldsNameOfStateInit) { + name = jsonFieldsNameOfStateInit[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 TokenRatesDiff24h) MarshalJSON() ([]byte, error) { +func (s *StateInit) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TokenRatesDiff24h) UnmarshalJSON(data []byte) error { +func (s *StateInit) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s TokenRatesDiff30d) Encode(e *jx.Encoder) { +func (s *StoragePhase) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s TokenRatesDiff30d) encodeFields(e *jx.Encoder) { - for k, elem := range s { - e.FieldStart(k) - - e.Str(elem) - } -} - -// Decode decodes TokenRatesDiff30d from json. -func (s *TokenRatesDiff30d) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode TokenRatesDiff30d to nil") - } - m := s.init() - if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - var elem string - if err := func() error { - v, err := d.Str() - elem = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrapf(err, "decode field %q", k) - } - m[string(k)] = elem - return nil - }); err != nil { - return errors.Wrap(err, "decode TokenRatesDiff30d") - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s TokenRatesDiff30d) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TokenRatesDiff30d) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s TokenRatesDiff7d) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields implements json.Marshaler. -func (s TokenRatesDiff7d) encodeFields(e *jx.Encoder) { - for k, elem := range s { - e.FieldStart(k) - - e.Str(elem) - } -} - -// Decode decodes TokenRatesDiff7d from json. -func (s *TokenRatesDiff7d) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode TokenRatesDiff7d to nil") - } - m := s.init() - if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - var elem string - if err := func() error { - v, err := d.Str() - elem = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrapf(err, "decode field %q", k) - } - m[string(k)] = elem - return nil - }); err != nil { - return errors.Wrap(err, "decode TokenRatesDiff7d") - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s TokenRatesDiff7d) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TokenRatesDiff7d) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s TokenRatesPrices) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields implements json.Marshaler. -func (s TokenRatesPrices) encodeFields(e *jx.Encoder) { - for k, elem := range s { - e.FieldStart(k) - - e.Float64(elem) - } -} - -// Decode decodes TokenRatesPrices from json. -func (s *TokenRatesPrices) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode TokenRatesPrices to nil") +// encodeFields encodes fields. +func (s *StoragePhase) encodeFields(e *jx.Encoder) { + { + e.FieldStart("fees_collected") + e.Int64(s.FeesCollected) } - m := s.init() - if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - var elem float64 - if err := func() error { - v, err := d.Float64() - elem = float64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrapf(err, "decode field %q", k) + { + if s.FeesDue.Set { + e.FieldStart("fees_due") + s.FeesDue.Encode(e) } - m[string(k)] = elem - return nil - }); err != nil { - return errors.Wrap(err, "decode TokenRatesPrices") } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s TokenRatesPrices) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TokenRatesPrices) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s *TonConnectProofOK) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *TonConnectProofOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("token") - e.Str(s.Token) + e.FieldStart("status_change") + s.StatusChange.Encode(e) } } -var jsonFieldsNameOfTonConnectProofOK = [1]string{ - 0: "token", +var jsonFieldsNameOfStoragePhase = [3]string{ + 0: "fees_collected", + 1: "fees_due", + 2: "status_change", } -// Decode decodes TonConnectProofOK from json. -func (s *TonConnectProofOK) Decode(d *jx.Decoder) error { +// Decode decodes StoragePhase from json. +func (s *StoragePhase) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode TonConnectProofOK to nil") + return errors.New("invalid: unable to decode StoragePhase to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "token": + case "fees_collected": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Token = string(v) + v, err := d.Int64() + s.FeesCollected = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"token\"") + return errors.Wrap(err, "decode field \"fees_collected\"") + } + case "fees_due": + if err := func() error { + s.FeesDue.Reset() + if err := s.FeesDue.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"fees_due\"") + } + case "status_change": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.StatusChange.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status_change\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode TonConnectProofOK") + return errors.Wrap(err, "decode StoragePhase") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000101, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -35538,8 +38832,8 @@ func (s *TonConnectProofOK) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfTonConnectProofOK) { - name = jsonFieldsNameOfTonConnectProofOK[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfStoragePhase) { + name = jsonFieldsNameOfStoragePhase[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -35560,46 +38854,66 @@ func (s *TonConnectProofOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *TonConnectProofOK) MarshalJSON() ([]byte, error) { +func (s *StoragePhase) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TonConnectProofOK) UnmarshalJSON(data []byte) error { +func (s *StoragePhase) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *TonConnectProofReq) Encode(e *jx.Encoder) { +func (s *StorageProvider) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *TonConnectProofReq) encodeFields(e *jx.Encoder) { +func (s *StorageProvider) encodeFields(e *jx.Encoder) { { e.FieldStart("address") e.Str(s.Address) } { - e.FieldStart("proof") - s.Proof.Encode(e) + e.FieldStart("accept_new_contracts") + e.Bool(s.AcceptNewContracts) + } + { + e.FieldStart("rate_per_mb_day") + e.Int64(s.RatePerMBDay) + } + { + e.FieldStart("max_span") + e.Int64(s.MaxSpan) + } + { + e.FieldStart("minimal_file_size") + e.Int64(s.MinimalFileSize) + } + { + e.FieldStart("maximal_file_size") + e.Int64(s.MaximalFileSize) } } -var jsonFieldsNameOfTonConnectProofReq = [2]string{ +var jsonFieldsNameOfStorageProvider = [6]string{ 0: "address", - 1: "proof", + 1: "accept_new_contracts", + 2: "rate_per_mb_day", + 3: "max_span", + 4: "minimal_file_size", + 5: "maximal_file_size", } -// Decode decodes TonConnectProofReq from json. -func (s *TonConnectProofReq) Decode(d *jx.Decoder) error { +// Decode decodes StorageProvider from json. +func (s *StorageProvider) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode TonConnectProofReq to nil") + return errors.New("invalid: unable to decode StorageProvider to nil") } var requiredBitSet [1]uint8 @@ -35617,27 +38931,77 @@ func (s *TonConnectProofReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"address\"") } - case "proof": + case "accept_new_contracts": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Proof.Decode(d); err != nil { + v, err := d.Bool() + s.AcceptNewContracts = bool(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"proof\"") + return errors.Wrap(err, "decode field \"accept_new_contracts\"") + } + case "rate_per_mb_day": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int64() + s.RatePerMBDay = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"rate_per_mb_day\"") + } + case "max_span": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Int64() + s.MaxSpan = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_span\"") + } + case "minimal_file_size": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int64() + s.MinimalFileSize = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"minimal_file_size\"") + } + case "maximal_file_size": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Int64() + s.MaximalFileSize = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"maximal_file_size\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode TonConnectProofReq") + return errors.Wrap(err, "decode StorageProvider") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000011, + 0b00111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -35649,8 +39013,8 @@ func (s *TonConnectProofReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfTonConnectProofReq) { - name = jsonFieldsNameOfTonConnectProofReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfStorageProvider) { + name = jsonFieldsNameOfStorageProvider[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -35671,135 +39035,232 @@ func (s *TonConnectProofReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *TonConnectProofReq) MarshalJSON() ([]byte, error) { +func (s *StorageProvider) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TonConnectProofReq) UnmarshalJSON(data []byte) error { +func (s *StorageProvider) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *TonConnectProofReqProof) Encode(e *jx.Encoder) { +func (s *Subscription) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *TonConnectProofReqProof) encodeFields(e *jx.Encoder) { +func (s *Subscription) encodeFields(e *jx.Encoder) { { - e.FieldStart("timestamp") - e.Int64(s.Timestamp) + e.FieldStart("type") + e.Str(s.Type) } { - e.FieldStart("domain") - s.Domain.Encode(e) + e.FieldStart("status") + s.Status.Encode(e) } { - e.FieldStart("signature") - e.Str(s.Signature) + e.FieldStart("period") + e.Int64(s.Period) } { - e.FieldStart("payload") - e.Str(s.Payload) + e.FieldStart("subscription_id") + e.Str(s.SubscriptionID) } { - if s.StateInit.Set { - e.FieldStart("state_init") - s.StateInit.Encode(e) + e.FieldStart("payment_per_period") + s.PaymentPerPeriod.Encode(e) + } + { + e.FieldStart("wallet") + s.Wallet.Encode(e) + } + { + e.FieldStart("next_charge_at") + e.Int64(s.NextChargeAt) + } + { + e.FieldStart("metadata") + s.Metadata.Encode(e) + } + { + if s.Address.Set { + e.FieldStart("address") + s.Address.Encode(e) + } + } + { + if s.Beneficiary.Set { + e.FieldStart("beneficiary") + s.Beneficiary.Encode(e) + } + } + { + if s.Admin.Set { + e.FieldStart("admin") + s.Admin.Encode(e) } } } -var jsonFieldsNameOfTonConnectProofReqProof = [5]string{ - 0: "timestamp", - 1: "domain", - 2: "signature", - 3: "payload", - 4: "state_init", +var jsonFieldsNameOfSubscription = [11]string{ + 0: "type", + 1: "status", + 2: "period", + 3: "subscription_id", + 4: "payment_per_period", + 5: "wallet", + 6: "next_charge_at", + 7: "metadata", + 8: "address", + 9: "beneficiary", + 10: "admin", } -// Decode decodes TonConnectProofReqProof from json. -func (s *TonConnectProofReqProof) Decode(d *jx.Decoder) error { +// Decode decodes Subscription from json. +func (s *Subscription) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode TonConnectProofReqProof to nil") + return errors.New("invalid: unable to decode Subscription 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 "timestamp": + case "type": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.Timestamp = int64(v) + v, err := d.Str() + s.Type = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"timestamp\"") + return errors.Wrap(err, "decode field \"type\"") } - case "domain": + case "status": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Domain.Decode(d); err != nil { + if err := s.Status.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"domain\"") + return errors.Wrap(err, "decode field \"status\"") } - case "signature": + case "period": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Str() - s.Signature = string(v) + v, err := d.Int64() + s.Period = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"signature\"") + return errors.Wrap(err, "decode field \"period\"") } - case "payload": + case "subscription_id": requiredBitSet[0] |= 1 << 3 if err := func() error { v, err := d.Str() - s.Payload = string(v) + s.SubscriptionID = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"payload\"") + return errors.Wrap(err, "decode field \"subscription_id\"") } - case "state_init": + case "payment_per_period": + requiredBitSet[0] |= 1 << 4 if err := func() error { - s.StateInit.Reset() - if err := s.StateInit.Decode(d); err != nil { + if err := s.PaymentPerPeriod.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"state_init\"") + return errors.Wrap(err, "decode field \"payment_per_period\"") + } + case "wallet": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + if err := s.Wallet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet\"") + } + case "next_charge_at": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + v, err := d.Int64() + s.NextChargeAt = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"next_charge_at\"") + } + case "metadata": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + if err := s.Metadata.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"metadata\"") + } + case "address": + if err := func() error { + s.Address.Reset() + if err := s.Address.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"address\"") + } + case "beneficiary": + if err := func() error { + s.Beneficiary.Reset() + if err := s.Beneficiary.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"beneficiary\"") + } + case "admin": + if err := func() error { + s.Admin.Reset() + if err := s.Admin.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"admin\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode TonConnectProofReqProof") + return errors.Wrap(err, "decode Subscription") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ - 0b00001111, + for i, mask := range [2]uint8{ + 0b11111111, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -35811,8 +39272,8 @@ func (s *TonConnectProofReqProof) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfTonConnectProofReqProof) { - name = jsonFieldsNameOfTonConnectProofReqProof[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSubscription) { + name = jsonFieldsNameOfSubscription[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -35833,263 +39294,163 @@ func (s *TonConnectProofReqProof) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *TonConnectProofReqProof) MarshalJSON() ([]byte, error) { +func (s *Subscription) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TonConnectProofReqProof) UnmarshalJSON(data []byte) error { +func (s *Subscription) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *TonConnectProofReqProofDomain) Encode(e *jx.Encoder) { +func (s *SubscriptionAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *TonConnectProofReqProofDomain) encodeFields(e *jx.Encoder) { +func (s *SubscriptionAction) encodeFields(e *jx.Encoder) { { - if s.LengthBytes.Set { - e.FieldStart("length_bytes") - s.LengthBytes.Encode(e) - } + e.FieldStart("subscriber") + s.Subscriber.Encode(e) } { - e.FieldStart("value") - e.Str(s.Value) - } -} - -var jsonFieldsNameOfTonConnectProofReqProofDomain = [2]string{ - 0: "length_bytes", - 1: "value", -} - -// Decode decodes TonConnectProofReqProofDomain from json. -func (s *TonConnectProofReqProofDomain) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode TonConnectProofReqProofDomain to nil") - } - var requiredBitSet [1]uint8 - - if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - switch string(k) { - case "length_bytes": - if err := func() error { - s.LengthBytes.Reset() - if err := s.LengthBytes.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"length_bytes\"") - } - 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 TonConnectProofReqProofDomain") - } - // Validate required fields. - var failures []validate.FieldError - for i, mask := range [1]uint8{ - 0b00000010, - } { - 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(jsonFieldsNameOfTonConnectProofReqProofDomain) { - name = jsonFieldsNameOfTonConnectProofReqProofDomain[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 *TonConnectProofReqProofDomain) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TonConnectProofReqProofDomain) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s *TonTransferAction) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *TonTransferAction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("sender") - s.Sender.Encode(e) + e.FieldStart("subscription") + e.Str(s.Subscription) } { - e.FieldStart("recipient") - s.Recipient.Encode(e) + e.FieldStart("beneficiary") + s.Beneficiary.Encode(e) } { - e.FieldStart("amount") - e.Int64(s.Amount) + e.FieldStart("admin") + s.Admin.Encode(e) } { - if s.Comment.Set { - e.FieldStart("comment") - s.Comment.Encode(e) + if s.Amount.Set { + e.FieldStart("amount") + s.Amount.Encode(e) } } { - if s.EncryptedComment.Set { - e.FieldStart("encrypted_comment") - s.EncryptedComment.Encode(e) - } + e.FieldStart("price") + s.Price.Encode(e) } { - if s.Refund.Set { - e.FieldStart("refund") - s.Refund.Encode(e) - } + e.FieldStart("initial") + e.Bool(s.Initial) } } -var jsonFieldsNameOfTonTransferAction = [6]string{ - 0: "sender", - 1: "recipient", - 2: "amount", - 3: "comment", - 4: "encrypted_comment", - 5: "refund", +var jsonFieldsNameOfSubscriptionAction = [7]string{ + 0: "subscriber", + 1: "subscription", + 2: "beneficiary", + 3: "admin", + 4: "amount", + 5: "price", + 6: "initial", } -// Decode decodes TonTransferAction from json. -func (s *TonTransferAction) Decode(d *jx.Decoder) error { +// Decode decodes SubscriptionAction from json. +func (s *SubscriptionAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode TonTransferAction to nil") + return errors.New("invalid: unable to decode SubscriptionAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "sender": + case "subscriber": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Sender.Decode(d); err != nil { + if err := s.Subscriber.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"sender\"") + return errors.Wrap(err, "decode field \"subscriber\"") } - case "recipient": + case "subscription": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Recipient.Decode(d); err != nil { + v, err := d.Str() + s.Subscription = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"recipient\"") + return errors.Wrap(err, "decode field \"subscription\"") } - case "amount": + case "beneficiary": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Int64() - s.Amount = int64(v) - if err != nil { + if err := s.Beneficiary.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") + return errors.Wrap(err, "decode field \"beneficiary\"") } - case "comment": + case "admin": + requiredBitSet[0] |= 1 << 3 if err := func() error { - s.Comment.Reset() - if err := s.Comment.Decode(d); err != nil { + if err := s.Admin.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"comment\"") + return errors.Wrap(err, "decode field \"admin\"") } - case "encrypted_comment": + case "amount": if err := func() error { - s.EncryptedComment.Reset() - if err := s.EncryptedComment.Decode(d); err != nil { + s.Amount.Reset() + if err := s.Amount.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"encrypted_comment\"") + return errors.Wrap(err, "decode field \"amount\"") } - case "refund": + case "price": + requiredBitSet[0] |= 1 << 5 if err := func() error { - s.Refund.Reset() - if err := s.Refund.Decode(d); err != nil { + if err := s.Price.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"refund\"") + return errors.Wrap(err, "decode field \"price\"") + } + case "initial": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + v, err := d.Bool() + s.Initial = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"initial\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode TonTransferAction") + return errors.Wrap(err, "decode SubscriptionAction") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b01101111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -36101,8 +39462,8 @@ func (s *TonTransferAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfTonTransferAction) { - name = jsonFieldsNameOfTonTransferAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSubscriptionAction) { + name = jsonFieldsNameOfSubscriptionAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -36123,141 +39484,123 @@ func (s *TonTransferAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *TonTransferAction) MarshalJSON() ([]byte, error) { +func (s *SubscriptionAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TonTransferAction) UnmarshalJSON(data []byte) error { +func (s *SubscriptionAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes SubscriptionStatus as json. +func (s SubscriptionStatus) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes SubscriptionStatus from json. +func (s *SubscriptionStatus) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode SubscriptionStatus to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch SubscriptionStatus(v) { + case SubscriptionStatusNotReady: + *s = SubscriptionStatusNotReady + case SubscriptionStatusActive: + *s = SubscriptionStatusActive + case SubscriptionStatusSuspended: + *s = SubscriptionStatusSuspended + case SubscriptionStatusCancelled: + *s = SubscriptionStatusCancelled + default: + *s = SubscriptionStatus(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s SubscriptionStatus) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *SubscriptionStatus) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Trace) Encode(e *jx.Encoder) { +func (s *Subscriptions) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Trace) encodeFields(e *jx.Encoder) { - { - e.FieldStart("transaction") - s.Transaction.Encode(e) - } +func (s *Subscriptions) encodeFields(e *jx.Encoder) { { - e.FieldStart("interfaces") + e.FieldStart("subscriptions") e.ArrStart() - for _, elem := range s.Interfaces { - e.Str(elem) + for _, elem := range s.Subscriptions { + elem.Encode(e) } e.ArrEnd() } - { - if s.Children != nil { - e.FieldStart("children") - e.ArrStart() - for _, elem := range s.Children { - elem.Encode(e) - } - e.ArrEnd() - } - } - { - if s.Emulated.Set { - e.FieldStart("emulated") - s.Emulated.Encode(e) - } - } } -var jsonFieldsNameOfTrace = [4]string{ - 0: "transaction", - 1: "interfaces", - 2: "children", - 3: "emulated", +var jsonFieldsNameOfSubscriptions = [1]string{ + 0: "subscriptions", } -// Decode decodes Trace from json. -func (s *Trace) Decode(d *jx.Decoder) error { +// Decode decodes Subscriptions from json. +func (s *Subscriptions) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Trace to nil") + return errors.New("invalid: unable to decode Subscriptions to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "transaction": + case "subscriptions": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Transaction.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"transaction\"") - } - case "interfaces": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - s.Interfaces = make([]string, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { - return err - } - s.Interfaces = append(s.Interfaces, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"interfaces\"") - } - case "children": - if err := func() error { - s.Children = make([]Trace, 0) + s.Subscriptions = make([]Subscription, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem Trace + var elem Subscription if err := elem.Decode(d); err != nil { return err } - s.Children = append(s.Children, elem) + s.Subscriptions = append(s.Subscriptions, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"children\"") - } - case "emulated": - if err := func() error { - s.Emulated.Reset() - if err := s.Emulated.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"emulated\"") + return errors.Wrap(err, "decode field \"subscriptions\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Trace") + return errors.Wrap(err, "decode Subscriptions") } // 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. @@ -36269,8 +39612,8 @@ func (s *Trace) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfTrace) { - name = jsonFieldsNameOfTrace[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfSubscriptions) { + name = jsonFieldsNameOfSubscriptions[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -36291,187 +39634,2234 @@ func (s *Trace) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Trace) MarshalJSON() ([]byte, error) { +func (s *Subscriptions) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Trace) UnmarshalJSON(data []byte) error { +func (s *Subscriptions) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *TraceID) Encode(e *jx.Encoder) { +func (s *TokenRates) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *TraceID) encodeFields(e *jx.Encoder) { +func (s *TokenRates) encodeFields(e *jx.Encoder) { { - e.FieldStart("id") - e.Str(s.ID) + if s.Prices.Set { + e.FieldStart("prices") + s.Prices.Encode(e) + } } { - e.FieldStart("utime") - e.Int64(s.Utime) + if s.Diff24h.Set { + e.FieldStart("diff_24h") + s.Diff24h.Encode(e) + } + } + { + if s.Diff7d.Set { + e.FieldStart("diff_7d") + s.Diff7d.Encode(e) + } + } + { + if s.Diff30d.Set { + e.FieldStart("diff_30d") + s.Diff30d.Encode(e) + } } } -var jsonFieldsNameOfTraceID = [2]string{ - 0: "id", - 1: "utime", +var jsonFieldsNameOfTokenRates = [4]string{ + 0: "prices", + 1: "diff_24h", + 2: "diff_7d", + 3: "diff_30d", } -// Decode decodes TraceID from json. -func (s *TraceID) Decode(d *jx.Decoder) error { +// Decode decodes TokenRates from json. +func (s *TokenRates) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode TraceID to nil") + return errors.New("invalid: unable to decode TokenRates 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 + case "prices": if err := func() error { - v, err := d.Str() - s.ID = string(v) - if err != nil { + s.Prices.Reset() + if err := s.Prices.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"id\"") + return errors.Wrap(err, "decode field \"prices\"") } - case "utime": - requiredBitSet[0] |= 1 << 1 + case "diff_24h": if err := func() error { - v, err := d.Int64() - s.Utime = int64(v) - if err != nil { + s.Diff24h.Reset() + if err := s.Diff24h.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"utime\"") + return errors.Wrap(err, "decode field \"diff_24h\"") + } + case "diff_7d": + if err := func() error { + s.Diff7d.Reset() + if err := s.Diff7d.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"diff_7d\"") + } + case "diff_30d": + if err := func() error { + s.Diff30d.Reset() + if err := s.Diff30d.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"diff_30d\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode TraceID") - } - // 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(jsonFieldsNameOfTraceID) { - name = jsonFieldsNameOfTraceID[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 errors.Wrap(err, "decode TokenRates") } return nil } // MarshalJSON implements stdjson.Marshaler. -func (s *TraceID) MarshalJSON() ([]byte, error) { +func (s *TokenRates) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TraceID) UnmarshalJSON(data []byte) error { +func (s *TokenRates) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *TraceIDs) Encode(e *jx.Encoder) { +func (s TokenRatesDiff24h) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields encodes fields. -func (s *TraceIDs) encodeFields(e *jx.Encoder) { - { - e.FieldStart("traces") - e.ArrStart() - for _, elem := range s.Traces { - elem.Encode(e) - } - e.ArrEnd() - } -} +// encodeFields implements json.Marshaler. +func (s TokenRatesDiff24h) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) -var jsonFieldsNameOfTraceIDs = [1]string{ - 0: "traces", + e.Str(elem) + } } -// Decode decodes TraceIDs from json. -func (s *TraceIDs) Decode(d *jx.Decoder) error { +// Decode decodes TokenRatesDiff24h from json. +func (s *TokenRatesDiff24h) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode TraceIDs to nil") + return errors.New("invalid: unable to decode TokenRatesDiff24h to nil") } - var requiredBitSet [1]uint8 - + m := s.init() if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - switch string(k) { - case "traces": - requiredBitSet[0] |= 1 << 0 - if err := func() error { - s.Traces = make([]TraceID, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem TraceID - if err := elem.Decode(d); err != nil { - return err - } - s.Traces = append(s.Traces, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"traces\"") + var elem string + if err := func() error { + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode TokenRatesDiff24h") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s TokenRatesDiff24h) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TokenRatesDiff24h) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s TokenRatesDiff30d) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s TokenRatesDiff30d) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + e.Str(elem) + } +} + +// Decode decodes TokenRatesDiff30d from json. +func (s *TokenRatesDiff30d) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TokenRatesDiff30d to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem string + if err := func() error { + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode TokenRatesDiff30d") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s TokenRatesDiff30d) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TokenRatesDiff30d) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s TokenRatesDiff7d) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s TokenRatesDiff7d) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + e.Str(elem) + } +} + +// Decode decodes TokenRatesDiff7d from json. +func (s *TokenRatesDiff7d) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TokenRatesDiff7d to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem string + if err := func() error { + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode TokenRatesDiff7d") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s TokenRatesDiff7d) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TokenRatesDiff7d) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s TokenRatesPrices) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s TokenRatesPrices) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + e.Float64(elem) + } +} + +// Decode decodes TokenRatesPrices from json. +func (s *TokenRatesPrices) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TokenRatesPrices to nil") + } + m := s.init() + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + var elem float64 + if err := func() error { + v, err := d.Float64() + elem = float64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrapf(err, "decode field %q", k) + } + m[string(k)] = elem + return nil + }); err != nil { + return errors.Wrap(err, "decode TokenRatesPrices") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s TokenRatesPrices) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TokenRatesPrices) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *TonConnectProofOK) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *TonConnectProofOK) encodeFields(e *jx.Encoder) { + { + e.FieldStart("token") + e.Str(s.Token) + } +} + +var jsonFieldsNameOfTonConnectProofOK = [1]string{ + 0: "token", +} + +// Decode decodes TonConnectProofOK from json. +func (s *TonConnectProofOK) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TonConnectProofOK to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "token": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Token = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"token\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode TonConnectProofOK") + } + // 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(jsonFieldsNameOfTonConnectProofOK) { + name = jsonFieldsNameOfTonConnectProofOK[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 *TonConnectProofOK) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TonConnectProofOK) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *TonConnectProofReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *TonConnectProofReq) encodeFields(e *jx.Encoder) { + { + e.FieldStart("address") + e.Str(s.Address) + } + { + e.FieldStart("proof") + s.Proof.Encode(e) + } +} + +var jsonFieldsNameOfTonConnectProofReq = [2]string{ + 0: "address", + 1: "proof", +} + +// Decode decodes TonConnectProofReq from json. +func (s *TonConnectProofReq) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TonConnectProofReq to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "address": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Address = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"address\"") + } + case "proof": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Proof.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"proof\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode TonConnectProofReq") + } + // 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(jsonFieldsNameOfTonConnectProofReq) { + name = jsonFieldsNameOfTonConnectProofReq[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 *TonConnectProofReq) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TonConnectProofReq) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *TonConnectProofReqProof) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *TonConnectProofReqProof) encodeFields(e *jx.Encoder) { + { + e.FieldStart("timestamp") + e.Int64(s.Timestamp) + } + { + e.FieldStart("domain") + s.Domain.Encode(e) + } + { + e.FieldStart("signature") + e.Str(s.Signature) + } + { + e.FieldStart("payload") + e.Str(s.Payload) + } + { + if s.StateInit.Set { + e.FieldStart("state_init") + s.StateInit.Encode(e) + } + } +} + +var jsonFieldsNameOfTonConnectProofReqProof = [5]string{ + 0: "timestamp", + 1: "domain", + 2: "signature", + 3: "payload", + 4: "state_init", +} + +// Decode decodes TonConnectProofReqProof from json. +func (s *TonConnectProofReqProof) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TonConnectProofReqProof to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "timestamp": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int64() + s.Timestamp = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"timestamp\"") + } + case "domain": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Domain.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"domain\"") + } + case "signature": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Signature = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"signature\"") + } + case "payload": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.Payload = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"payload\"") + } + case "state_init": + if err := func() error { + s.StateInit.Reset() + if err := s.StateInit.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"state_init\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode TonConnectProofReqProof") + } + // 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(jsonFieldsNameOfTonConnectProofReqProof) { + name = jsonFieldsNameOfTonConnectProofReqProof[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 *TonConnectProofReqProof) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TonConnectProofReqProof) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *TonConnectProofReqProofDomain) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *TonConnectProofReqProofDomain) encodeFields(e *jx.Encoder) { + { + if s.LengthBytes.Set { + e.FieldStart("length_bytes") + s.LengthBytes.Encode(e) + } + } + { + e.FieldStart("value") + e.Str(s.Value) + } +} + +var jsonFieldsNameOfTonConnectProofReqProofDomain = [2]string{ + 0: "length_bytes", + 1: "value", +} + +// Decode decodes TonConnectProofReqProofDomain from json. +func (s *TonConnectProofReqProofDomain) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TonConnectProofReqProofDomain to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "length_bytes": + if err := func() error { + s.LengthBytes.Reset() + if err := s.LengthBytes.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"length_bytes\"") + } + 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 TonConnectProofReqProofDomain") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000010, + } { + 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(jsonFieldsNameOfTonConnectProofReqProofDomain) { + name = jsonFieldsNameOfTonConnectProofReqProofDomain[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 *TonConnectProofReqProofDomain) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TonConnectProofReqProofDomain) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *TonTransferAction) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *TonTransferAction) encodeFields(e *jx.Encoder) { + { + e.FieldStart("sender") + s.Sender.Encode(e) + } + { + e.FieldStart("recipient") + s.Recipient.Encode(e) + } + { + e.FieldStart("amount") + e.Int64(s.Amount) + } + { + if s.Comment.Set { + e.FieldStart("comment") + s.Comment.Encode(e) + } + } + { + if s.EncryptedComment.Set { + e.FieldStart("encrypted_comment") + s.EncryptedComment.Encode(e) + } + } + { + if s.Refund.Set { + e.FieldStart("refund") + s.Refund.Encode(e) + } + } +} + +var jsonFieldsNameOfTonTransferAction = [6]string{ + 0: "sender", + 1: "recipient", + 2: "amount", + 3: "comment", + 4: "encrypted_comment", + 5: "refund", +} + +// Decode decodes TonTransferAction from json. +func (s *TonTransferAction) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TonTransferAction to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "sender": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Sender.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"sender\"") + } + case "recipient": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Recipient.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"recipient\"") + } + case "amount": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int64() + s.Amount = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"amount\"") + } + case "comment": + if err := func() error { + s.Comment.Reset() + if err := s.Comment.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"comment\"") + } + case "encrypted_comment": + if err := func() error { + s.EncryptedComment.Reset() + if err := s.EncryptedComment.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"encrypted_comment\"") + } + case "refund": + if err := func() error { + s.Refund.Reset() + if err := s.Refund.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"refund\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode TonTransferAction") + } + // 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(jsonFieldsNameOfTonTransferAction) { + name = jsonFieldsNameOfTonTransferAction[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 *TonTransferAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TonTransferAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *Trace) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *Trace) encodeFields(e *jx.Encoder) { + { + e.FieldStart("transaction") + s.Transaction.Encode(e) + } + { + e.FieldStart("interfaces") + e.ArrStart() + for _, elem := range s.Interfaces { + e.Str(elem) + } + e.ArrEnd() + } + { + if s.Children != nil { + e.FieldStart("children") + e.ArrStart() + for _, elem := range s.Children { + elem.Encode(e) + } + e.ArrEnd() + } + } + { + if s.Emulated.Set { + e.FieldStart("emulated") + s.Emulated.Encode(e) + } + } +} + +var jsonFieldsNameOfTrace = [4]string{ + 0: "transaction", + 1: "interfaces", + 2: "children", + 3: "emulated", +} + +// Decode decodes Trace from json. +func (s *Trace) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode Trace to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "transaction": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Transaction.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"transaction\"") + } + case "interfaces": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + s.Interfaces = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Interfaces = append(s.Interfaces, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"interfaces\"") + } + case "children": + if err := func() error { + s.Children = make([]Trace, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem Trace + if err := elem.Decode(d); err != nil { + return err + } + s.Children = append(s.Children, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"children\"") + } + case "emulated": + if err := func() error { + s.Emulated.Reset() + if err := s.Emulated.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"emulated\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode Trace") + } + // 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(jsonFieldsNameOfTrace) { + name = jsonFieldsNameOfTrace[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 *Trace) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *Trace) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *TraceID) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *TraceID) encodeFields(e *jx.Encoder) { + { + e.FieldStart("id") + e.Str(s.ID) + } + { + e.FieldStart("utime") + e.Int64(s.Utime) + } +} + +var jsonFieldsNameOfTraceID = [2]string{ + 0: "id", + 1: "utime", +} + +// Decode decodes TraceID from json. +func (s *TraceID) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TraceID 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.Str() + s.ID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "utime": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int64() + s.Utime = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"utime\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode TraceID") + } + // 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(jsonFieldsNameOfTraceID) { + name = jsonFieldsNameOfTraceID[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 *TraceID) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TraceID) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *TraceIDs) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *TraceIDs) encodeFields(e *jx.Encoder) { + { + e.FieldStart("traces") + e.ArrStart() + for _, elem := range s.Traces { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfTraceIDs = [1]string{ + 0: "traces", +} + +// Decode decodes TraceIDs from json. +func (s *TraceIDs) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TraceIDs to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "traces": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Traces = make([]TraceID, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem TraceID + if err := elem.Decode(d); err != nil { + return err + } + s.Traces = append(s.Traces, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"traces\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode TraceIDs") + } + // 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(jsonFieldsNameOfTraceIDs) { + name = jsonFieldsNameOfTraceIDs[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 *TraceIDs) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TraceIDs) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *Transaction) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *Transaction) encodeFields(e *jx.Encoder) { + { + e.FieldStart("hash") + e.Str(s.Hash) + } + { + e.FieldStart("lt") + e.Int64(s.Lt) + } + { + e.FieldStart("account") + s.Account.Encode(e) + } + { + e.FieldStart("success") + e.Bool(s.Success) + } + { + e.FieldStart("utime") + e.Int64(s.Utime) + } + { + e.FieldStart("orig_status") + s.OrigStatus.Encode(e) + } + { + e.FieldStart("end_status") + s.EndStatus.Encode(e) + } + { + e.FieldStart("total_fees") + e.Int64(s.TotalFees) + } + { + e.FieldStart("end_balance") + e.Int64(s.EndBalance) + } + { + e.FieldStart("transaction_type") + s.TransactionType.Encode(e) + } + { + e.FieldStart("state_update_old") + e.Str(s.StateUpdateOld) + } + { + e.FieldStart("state_update_new") + e.Str(s.StateUpdateNew) + } + { + if s.InMsg.Set { + e.FieldStart("in_msg") + s.InMsg.Encode(e) + } + } + { + e.FieldStart("out_msgs") + e.ArrStart() + for _, elem := range s.OutMsgs { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("block") + e.Str(s.Block) + } + { + if s.PrevTransHash.Set { + e.FieldStart("prev_trans_hash") + s.PrevTransHash.Encode(e) + } + } + { + if s.PrevTransLt.Set { + e.FieldStart("prev_trans_lt") + s.PrevTransLt.Encode(e) + } + } + { + if s.ComputePhase.Set { + e.FieldStart("compute_phase") + s.ComputePhase.Encode(e) + } + } + { + if s.StoragePhase.Set { + e.FieldStart("storage_phase") + s.StoragePhase.Encode(e) + } + } + { + if s.CreditPhase.Set { + e.FieldStart("credit_phase") + s.CreditPhase.Encode(e) + } + } + { + if s.ActionPhase.Set { + e.FieldStart("action_phase") + s.ActionPhase.Encode(e) + } + } + { + if s.BouncePhase.Set { + e.FieldStart("bounce_phase") + s.BouncePhase.Encode(e) + } + } + { + e.FieldStart("aborted") + e.Bool(s.Aborted) + } + { + e.FieldStart("destroyed") + e.Bool(s.Destroyed) + } + { + e.FieldStart("raw") + e.Str(s.Raw) + } +} + +var jsonFieldsNameOfTransaction = [25]string{ + 0: "hash", + 1: "lt", + 2: "account", + 3: "success", + 4: "utime", + 5: "orig_status", + 6: "end_status", + 7: "total_fees", + 8: "end_balance", + 9: "transaction_type", + 10: "state_update_old", + 11: "state_update_new", + 12: "in_msg", + 13: "out_msgs", + 14: "block", + 15: "prev_trans_hash", + 16: "prev_trans_lt", + 17: "compute_phase", + 18: "storage_phase", + 19: "credit_phase", + 20: "action_phase", + 21: "bounce_phase", + 22: "aborted", + 23: "destroyed", + 24: "raw", +} + +// Decode decodes Transaction from json. +func (s *Transaction) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode Transaction to nil") + } + var requiredBitSet [4]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "hash": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Hash = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"hash\"") + } + case "lt": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int64() + s.Lt = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"lt\"") + } + case "account": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.Account.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"account\"") + } + case "success": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Bool() + s.Success = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"success\"") + } + case "utime": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int64() + s.Utime = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"utime\"") + } + case "orig_status": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + if err := s.OrigStatus.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"orig_status\"") + } + case "end_status": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + if err := s.EndStatus.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"end_status\"") + } + case "total_fees": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + v, err := d.Int64() + s.TotalFees = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"total_fees\"") + } + case "end_balance": + requiredBitSet[1] |= 1 << 0 + if err := func() error { + v, err := d.Int64() + s.EndBalance = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"end_balance\"") + } + case "transaction_type": + requiredBitSet[1] |= 1 << 1 + if err := func() error { + if err := s.TransactionType.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"transaction_type\"") + } + case "state_update_old": + requiredBitSet[1] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.StateUpdateOld = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"state_update_old\"") + } + case "state_update_new": + requiredBitSet[1] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.StateUpdateNew = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"state_update_new\"") + } + case "in_msg": + if err := func() error { + s.InMsg.Reset() + if err := s.InMsg.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"in_msg\"") + } + case "out_msgs": + requiredBitSet[1] |= 1 << 5 + if err := func() error { + s.OutMsgs = make([]Message, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem Message + if err := elem.Decode(d); err != nil { + return err + } + s.OutMsgs = append(s.OutMsgs, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"out_msgs\"") + } + case "block": + requiredBitSet[1] |= 1 << 6 + if err := func() error { + v, err := d.Str() + s.Block = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"block\"") + } + case "prev_trans_hash": + if err := func() error { + s.PrevTransHash.Reset() + if err := s.PrevTransHash.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"prev_trans_hash\"") + } + case "prev_trans_lt": + if err := func() error { + s.PrevTransLt.Reset() + if err := s.PrevTransLt.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"prev_trans_lt\"") + } + case "compute_phase": + if err := func() error { + s.ComputePhase.Reset() + if err := s.ComputePhase.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"compute_phase\"") + } + case "storage_phase": + if err := func() error { + s.StoragePhase.Reset() + if err := s.StoragePhase.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"storage_phase\"") + } + case "credit_phase": + if err := func() error { + s.CreditPhase.Reset() + if err := s.CreditPhase.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"credit_phase\"") + } + case "action_phase": + if err := func() error { + s.ActionPhase.Reset() + if err := s.ActionPhase.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"action_phase\"") + } + case "bounce_phase": + if err := func() error { + s.BouncePhase.Reset() + if err := s.BouncePhase.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bounce_phase\"") + } + case "aborted": + requiredBitSet[2] |= 1 << 6 + if err := func() error { + v, err := d.Bool() + s.Aborted = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"aborted\"") + } + case "destroyed": + requiredBitSet[2] |= 1 << 7 + if err := func() error { + v, err := d.Bool() + s.Destroyed = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"destroyed\"") + } + case "raw": + requiredBitSet[3] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Raw = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raw\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode Transaction") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [4]uint8{ + 0b11111111, + 0b01101111, + 0b11000000, + 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(jsonFieldsNameOfTransaction) { + name = jsonFieldsNameOfTransaction[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 *Transaction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *Transaction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes TransactionType as json. +func (s TransactionType) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes TransactionType from json. +func (s *TransactionType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TransactionType to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch TransactionType(v) { + case TransactionTypeTransOrd: + *s = TransactionTypeTransOrd + case TransactionTypeTransTickTock: + *s = TransactionTypeTransTickTock + case TransactionTypeTransSplitPrepare: + *s = TransactionTypeTransSplitPrepare + case TransactionTypeTransSplitInstall: + *s = TransactionTypeTransSplitInstall + case TransactionTypeTransMergePrepare: + *s = TransactionTypeTransMergePrepare + case TransactionTypeTransMergeInstall: + *s = TransactionTypeTransMergeInstall + case TransactionTypeTransStorage: + *s = TransactionTypeTransStorage + default: + *s = TransactionType(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s TransactionType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TransactionType) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *Transactions) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *Transactions) encodeFields(e *jx.Encoder) { + { + e.FieldStart("transactions") + e.ArrStart() + for _, elem := range s.Transactions { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfTransactions = [1]string{ + 0: "transactions", +} + +// Decode decodes Transactions from json. +func (s *Transactions) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode Transactions to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "transactions": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Transactions = make([]Transaction, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem Transaction + if err := elem.Decode(d); err != nil { + return err + } + s.Transactions = append(s.Transactions, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"transactions\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode Transactions") + } + // 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(jsonFieldsNameOfTransactions) { + name = jsonFieldsNameOfTransactions[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 *Transactions) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *Transactions) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes TrustType as json. +func (s TrustType) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes TrustType from json. +func (s *TrustType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TrustType to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch TrustType(v) { + case TrustTypeWhitelist: + *s = TrustTypeWhitelist + case TrustTypeGraylist: + *s = TrustTypeGraylist + case TrustTypeBlacklist: + *s = TrustTypeBlacklist + case TrustTypeNone: + *s = TrustTypeNone + default: + *s = TrustType(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s TrustType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TrustType) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *TvmStackRecord) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *TvmStackRecord) encodeFields(e *jx.Encoder) { + { + e.FieldStart("type") + s.Type.Encode(e) + } + { + if s.Cell.Set { + e.FieldStart("cell") + s.Cell.Encode(e) + } + } + { + if s.Slice.Set { + e.FieldStart("slice") + s.Slice.Encode(e) + } + } + { + if s.Num.Set { + e.FieldStart("num") + s.Num.Encode(e) + } + } + { + if s.Tuple != nil { + e.FieldStart("tuple") + e.ArrStart() + for _, elem := range s.Tuple { + elem.Encode(e) + } + e.ArrEnd() + } + } +} + +var jsonFieldsNameOfTvmStackRecord = [5]string{ + 0: "type", + 1: "cell", + 2: "slice", + 3: "num", + 4: "tuple", +} + +// Decode decodes TvmStackRecord from json. +func (s *TvmStackRecord) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TvmStackRecord to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "type": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + if err := s.Type.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"type\"") + } + case "cell": + if err := func() error { + s.Cell.Reset() + if err := s.Cell.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cell\"") + } + case "slice": + if err := func() error { + s.Slice.Reset() + if err := s.Slice.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"slice\"") + } + case "num": + if err := func() error { + s.Num.Reset() + if err := s.Num.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"num\"") + } + case "tuple": + if err := func() error { + s.Tuple = make([]TvmStackRecord, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem TvmStackRecord + if err := elem.Decode(d); err != nil { + return err + } + s.Tuple = append(s.Tuple, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"tuple\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode TraceIDs") + return errors.Wrap(err, "decode TvmStackRecord") } // Validate required fields. var failures []validate.FieldError @@ -36488,8 +41878,8 @@ func (s *TraceIDs) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfTraceIDs) { - name = jsonFieldsNameOfTraceIDs[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfTvmStackRecord) { + name = jsonFieldsNameOfTvmStackRecord[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -36510,482 +41900,672 @@ func (s *TraceIDs) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *TraceIDs) MarshalJSON() ([]byte, error) { +func (s *TvmStackRecord) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TraceIDs) UnmarshalJSON(data []byte) error { +func (s *TvmStackRecord) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes TvmStackRecordType as json. +func (s TvmStackRecordType) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes TvmStackRecordType from json. +func (s *TvmStackRecordType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode TvmStackRecordType to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch TvmStackRecordType(v) { + case TvmStackRecordTypeCell: + *s = TvmStackRecordTypeCell + case TvmStackRecordTypeNum: + *s = TvmStackRecordTypeNum + case TvmStackRecordTypeNan: + *s = TvmStackRecordTypeNan + case TvmStackRecordTypeNull: + *s = TvmStackRecordTypeNull + case TvmStackRecordTypeTuple: + *s = TvmStackRecordTypeTuple + default: + *s = TvmStackRecordType(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s TvmStackRecordType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *TvmStackRecordType) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Transaction) Encode(e *jx.Encoder) { +func (s *UnSubscriptionAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Transaction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("hash") - e.Str(s.Hash) - } - { - e.FieldStart("lt") - e.Int64(s.Lt) - } - { - e.FieldStart("account") - s.Account.Encode(e) - } - { - e.FieldStart("success") - e.Bool(s.Success) - } - { - e.FieldStart("utime") - e.Int64(s.Utime) - } - { - e.FieldStart("orig_status") - s.OrigStatus.Encode(e) - } - { - e.FieldStart("end_status") - s.EndStatus.Encode(e) - } - { - e.FieldStart("total_fees") - e.Int64(s.TotalFees) - } - { - e.FieldStart("end_balance") - e.Int64(s.EndBalance) - } - { - e.FieldStart("transaction_type") - s.TransactionType.Encode(e) - } - { - e.FieldStart("state_update_old") - e.Str(s.StateUpdateOld) - } - { - e.FieldStart("state_update_new") - e.Str(s.StateUpdateNew) - } - { - if s.InMsg.Set { - e.FieldStart("in_msg") - s.InMsg.Encode(e) - } - } - { - e.FieldStart("out_msgs") - e.ArrStart() - for _, elem := range s.OutMsgs { - elem.Encode(e) - } - e.ArrEnd() - } - { - e.FieldStart("block") - e.Str(s.Block) - } - { - if s.PrevTransHash.Set { - e.FieldStart("prev_trans_hash") - s.PrevTransHash.Encode(e) - } - } - { - if s.PrevTransLt.Set { - e.FieldStart("prev_trans_lt") - s.PrevTransLt.Encode(e) - } - } - { - if s.ComputePhase.Set { - e.FieldStart("compute_phase") - s.ComputePhase.Encode(e) - } - } - { - if s.StoragePhase.Set { - e.FieldStart("storage_phase") - s.StoragePhase.Encode(e) - } - } - { - if s.CreditPhase.Set { - e.FieldStart("credit_phase") - s.CreditPhase.Encode(e) - } - } - { - if s.ActionPhase.Set { - e.FieldStart("action_phase") - s.ActionPhase.Encode(e) - } - } +func (s *UnSubscriptionAction) encodeFields(e *jx.Encoder) { { - if s.BouncePhase.Set { - e.FieldStart("bounce_phase") - s.BouncePhase.Encode(e) - } + e.FieldStart("subscriber") + s.Subscriber.Encode(e) } { - e.FieldStart("aborted") - e.Bool(s.Aborted) + e.FieldStart("subscription") + e.Str(s.Subscription) } { - e.FieldStart("destroyed") - e.Bool(s.Destroyed) + e.FieldStart("beneficiary") + s.Beneficiary.Encode(e) } { - e.FieldStart("raw") - e.Str(s.Raw) + e.FieldStart("admin") + s.Admin.Encode(e) } } -var jsonFieldsNameOfTransaction = [25]string{ - 0: "hash", - 1: "lt", - 2: "account", - 3: "success", - 4: "utime", - 5: "orig_status", - 6: "end_status", - 7: "total_fees", - 8: "end_balance", - 9: "transaction_type", - 10: "state_update_old", - 11: "state_update_new", - 12: "in_msg", - 13: "out_msgs", - 14: "block", - 15: "prev_trans_hash", - 16: "prev_trans_lt", - 17: "compute_phase", - 18: "storage_phase", - 19: "credit_phase", - 20: "action_phase", - 21: "bounce_phase", - 22: "aborted", - 23: "destroyed", - 24: "raw", +var jsonFieldsNameOfUnSubscriptionAction = [4]string{ + 0: "subscriber", + 1: "subscription", + 2: "beneficiary", + 3: "admin", } -// Decode decodes Transaction from json. -func (s *Transaction) Decode(d *jx.Decoder) error { +// Decode decodes UnSubscriptionAction from json. +func (s *UnSubscriptionAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Transaction to nil") + return errors.New("invalid: unable to decode UnSubscriptionAction to nil") } - var requiredBitSet [4]uint8 + var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "hash": + case "subscriber": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Hash = string(v) - if err != nil { + if err := s.Subscriber.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"hash\"") + return errors.Wrap(err, "decode field \"subscriber\"") } - case "lt": + case "subscription": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int64() - s.Lt = int64(v) + v, err := d.Str() + s.Subscription = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"lt\"") + return errors.Wrap(err, "decode field \"subscription\"") } - case "account": + case "beneficiary": requiredBitSet[0] |= 1 << 2 if err := func() error { - if err := s.Account.Decode(d); err != nil { + if err := s.Beneficiary.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"account\"") + return errors.Wrap(err, "decode field \"beneficiary\"") } - case "success": + case "admin": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Bool() - s.Success = bool(v) + if err := s.Admin.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"admin\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode UnSubscriptionAction") + } + // 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(jsonFieldsNameOfUnSubscriptionAction) { + name = jsonFieldsNameOfUnSubscriptionAction[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 *UnSubscriptionAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *UnSubscriptionAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *Validator) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *Validator) encodeFields(e *jx.Encoder) { + { + e.FieldStart("address") + e.Str(s.Address) + } + { + e.FieldStart("adnl_address") + e.Str(s.AdnlAddress) + } + { + e.FieldStart("stake") + e.Int64(s.Stake) + } + { + e.FieldStart("max_factor") + e.Int64(s.MaxFactor) + } +} + +var jsonFieldsNameOfValidator = [4]string{ + 0: "address", + 1: "adnl_address", + 2: "stake", + 3: "max_factor", +} + +// Decode decodes Validator from json. +func (s *Validator) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode Validator to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "address": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Address = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"success\"") + return errors.Wrap(err, "decode field \"address\"") } - case "utime": - requiredBitSet[0] |= 1 << 4 + case "adnl_address": + requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int64() - s.Utime = int64(v) + v, err := d.Str() + s.AdnlAddress = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"utime\"") + return errors.Wrap(err, "decode field \"adnl_address\"") } - case "orig_status": - requiredBitSet[0] |= 1 << 5 + case "stake": + requiredBitSet[0] |= 1 << 2 if err := func() error { - if err := s.OrigStatus.Decode(d); err != nil { + v, err := d.Int64() + s.Stake = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"orig_status\"") + return errors.Wrap(err, "decode field \"stake\"") } - case "end_status": - requiredBitSet[0] |= 1 << 6 + case "max_factor": + requiredBitSet[0] |= 1 << 3 if err := func() error { - if err := s.EndStatus.Decode(d); err != nil { + v, err := d.Int64() + s.MaxFactor = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"end_status\"") + return errors.Wrap(err, "decode field \"max_factor\"") } - case "total_fees": - requiredBitSet[0] |= 1 << 7 + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode Validator") + } + // 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(jsonFieldsNameOfValidator) { + name = jsonFieldsNameOfValidator[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 *Validator) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *Validator) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *Validators) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *Validators) encodeFields(e *jx.Encoder) { + { + e.FieldStart("elect_at") + e.Int64(s.ElectAt) + } + { + e.FieldStart("elect_close") + e.Int64(s.ElectClose) + } + { + e.FieldStart("min_stake") + e.Int64(s.MinStake) + } + { + e.FieldStart("total_stake") + e.Int64(s.TotalStake) + } + { + e.FieldStart("validators") + e.ArrStart() + for _, elem := range s.Validators { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfValidators = [5]string{ + 0: "elect_at", + 1: "elect_close", + 2: "min_stake", + 3: "total_stake", + 4: "validators", +} + +// Decode decodes Validators from json. +func (s *Validators) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode Validators to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "elect_at": + requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Int64() - s.TotalFees = int64(v) + s.ElectAt = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"total_fees\"") + return errors.Wrap(err, "decode field \"elect_at\"") } - case "end_balance": - requiredBitSet[1] |= 1 << 0 + case "elect_close": + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Int64() - s.EndBalance = int64(v) + s.ElectClose = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"end_balance\"") - } - case "transaction_type": - requiredBitSet[1] |= 1 << 1 - if err := func() error { - if err := s.TransactionType.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"transaction_type\"") + return errors.Wrap(err, "decode field \"elect_close\"") } - case "state_update_old": - requiredBitSet[1] |= 1 << 2 + case "min_stake": + requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Str() - s.StateUpdateOld = string(v) + v, err := d.Int64() + s.MinStake = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"state_update_old\"") + return errors.Wrap(err, "decode field \"min_stake\"") } - case "state_update_new": - requiredBitSet[1] |= 1 << 3 + case "total_stake": + requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Str() - s.StateUpdateNew = string(v) + v, err := d.Int64() + s.TotalStake = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"state_update_new\"") - } - case "in_msg": - if err := func() error { - s.InMsg.Reset() - if err := s.InMsg.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"in_msg\"") + return errors.Wrap(err, "decode field \"total_stake\"") } - case "out_msgs": - requiredBitSet[1] |= 1 << 5 + case "validators": + requiredBitSet[0] |= 1 << 4 if err := func() error { - s.OutMsgs = make([]Message, 0) + s.Validators = make([]Validator, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem Message + var elem Validator if err := elem.Decode(d); err != nil { return err } - s.OutMsgs = append(s.OutMsgs, elem) + s.Validators = append(s.Validators, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"out_msgs\"") - } - case "block": - requiredBitSet[1] |= 1 << 6 - if err := func() error { - v, err := d.Str() - s.Block = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"block\"") - } - case "prev_trans_hash": - if err := func() error { - s.PrevTransHash.Reset() - if err := s.PrevTransHash.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"prev_trans_hash\"") - } - case "prev_trans_lt": - if err := func() error { - s.PrevTransLt.Reset() - if err := s.PrevTransLt.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"prev_trans_lt\"") - } - case "compute_phase": - if err := func() error { - s.ComputePhase.Reset() - if err := s.ComputePhase.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"compute_phase\"") + return errors.Wrap(err, "decode field \"validators\"") } - case "storage_phase": - if err := func() error { - s.StoragePhase.Reset() - if err := s.StoragePhase.Decode(d); err != nil { - return err + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode Validators") + } + // 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(jsonFieldsNameOfValidators) { + name = jsonFieldsNameOfValidators[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"storage_phase\"") + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx } - case "credit_phase": + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *Validators) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *Validators) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *ValidatorsSet) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *ValidatorsSet) encodeFields(e *jx.Encoder) { + { + e.FieldStart("utime_since") + e.Int(s.UtimeSince) + } + { + e.FieldStart("utime_until") + e.Int(s.UtimeUntil) + } + { + e.FieldStart("total") + e.Int(s.Total) + } + { + e.FieldStart("main") + e.Int(s.Main) + } + { + if s.TotalWeight.Set { + e.FieldStart("total_weight") + s.TotalWeight.Encode(e) + } + } + { + e.FieldStart("list") + e.ArrStart() + for _, elem := range s.List { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfValidatorsSet = [6]string{ + 0: "utime_since", + 1: "utime_until", + 2: "total", + 3: "main", + 4: "total_weight", + 5: "list", +} + +// Decode decodes ValidatorsSet from json. +func (s *ValidatorsSet) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode ValidatorsSet to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "utime_since": + requiredBitSet[0] |= 1 << 0 if err := func() error { - s.CreditPhase.Reset() - if err := s.CreditPhase.Decode(d); err != nil { + v, err := d.Int() + s.UtimeSince = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"credit_phase\"") + return errors.Wrap(err, "decode field \"utime_since\"") } - case "action_phase": + case "utime_until": + requiredBitSet[0] |= 1 << 1 if err := func() error { - s.ActionPhase.Reset() - if err := s.ActionPhase.Decode(d); err != nil { + v, err := d.Int() + s.UtimeUntil = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"action_phase\"") + return errors.Wrap(err, "decode field \"utime_until\"") } - case "bounce_phase": + case "total": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.BouncePhase.Reset() - if err := s.BouncePhase.Decode(d); err != nil { + v, err := d.Int() + s.Total = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"bounce_phase\"") + return errors.Wrap(err, "decode field \"total\"") } - case "aborted": - requiredBitSet[2] |= 1 << 6 + case "main": + requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Bool() - s.Aborted = bool(v) + v, err := d.Int() + s.Main = int(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"aborted\"") + return errors.Wrap(err, "decode field \"main\"") } - case "destroyed": - requiredBitSet[2] |= 1 << 7 + case "total_weight": if err := func() error { - v, err := d.Bool() - s.Destroyed = bool(v) - if err != nil { + s.TotalWeight.Reset() + if err := s.TotalWeight.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"destroyed\"") + return errors.Wrap(err, "decode field \"total_weight\"") } - case "raw": - requiredBitSet[3] |= 1 << 0 + case "list": + requiredBitSet[0] |= 1 << 5 if err := func() error { - v, err := d.Str() - s.Raw = string(v) - if err != nil { + s.List = make([]ValidatorsSetListItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ValidatorsSetListItem + if err := elem.Decode(d); err != nil { + return err + } + s.List = append(s.List, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"raw\"") + return errors.Wrap(err, "decode field \"list\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Transaction") + return errors.Wrap(err, "decode ValidatorsSet") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [4]uint8{ - 0b11111111, - 0b01101111, - 0b11000000, - 0b00000001, + for i, mask := range [1]uint8{ + 0b00101111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -36997,8 +42577,8 @@ func (s *Transaction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfTransaction) { - name = jsonFieldsNameOfTransaction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfValidatorsSet) { + name = jsonFieldsNameOfValidatorsSet[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -37019,129 +42599,103 @@ func (s *Transaction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Transaction) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Transaction) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes TransactionType as json. -func (s TransactionType) Encode(e *jx.Encoder) { - e.Str(string(s)) -} - -// Decode decodes TransactionType from json. -func (s *TransactionType) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode TransactionType to nil") - } - v, err := d.StrBytes() - if err != nil { - return err - } - // Try to use constant string. - switch TransactionType(v) { - case TransactionTypeTransOrd: - *s = TransactionTypeTransOrd - case TransactionTypeTransTickTock: - *s = TransactionTypeTransTickTock - case TransactionTypeTransSplitPrepare: - *s = TransactionTypeTransSplitPrepare - case TransactionTypeTransSplitInstall: - *s = TransactionTypeTransSplitInstall - case TransactionTypeTransMergePrepare: - *s = TransactionTypeTransMergePrepare - case TransactionTypeTransMergeInstall: - *s = TransactionTypeTransMergeInstall - case TransactionTypeTransStorage: - *s = TransactionTypeTransStorage - default: - *s = TransactionType(v) - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s TransactionType) MarshalJSON() ([]byte, error) { +func (s *ValidatorsSet) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TransactionType) UnmarshalJSON(data []byte) error { +func (s *ValidatorsSet) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Transactions) Encode(e *jx.Encoder) { +func (s *ValidatorsSetListItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Transactions) encodeFields(e *jx.Encoder) { +func (s *ValidatorsSetListItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("transactions") - e.ArrStart() - for _, elem := range s.Transactions { - elem.Encode(e) + e.FieldStart("public_key") + e.Str(s.PublicKey) + } + { + e.FieldStart("weight") + e.Int64(s.Weight) + } + { + if s.AdnlAddr.Set { + e.FieldStart("adnl_addr") + s.AdnlAddr.Encode(e) } - e.ArrEnd() } } -var jsonFieldsNameOfTransactions = [1]string{ - 0: "transactions", +var jsonFieldsNameOfValidatorsSetListItem = [3]string{ + 0: "public_key", + 1: "weight", + 2: "adnl_addr", } -// Decode decodes Transactions from json. -func (s *Transactions) Decode(d *jx.Decoder) error { +// Decode decodes ValidatorsSetListItem from json. +func (s *ValidatorsSetListItem) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Transactions to nil") + return errors.New("invalid: unable to decode ValidatorsSetListItem to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "transactions": + case "public_key": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Transactions = make([]Transaction, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem Transaction - if err := elem.Decode(d); err != nil { - return err - } - s.Transactions = append(s.Transactions, elem) - return nil - }); err != nil { + v, err := d.Str() + s.PublicKey = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"transactions\"") + return errors.Wrap(err, "decode field \"public_key\"") + } + case "weight": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int64() + s.Weight = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"weight\"") + } + case "adnl_addr": + if err := func() error { + s.AdnlAddr.Reset() + if err := s.AdnlAddr.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"adnl_addr\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Transactions") + return errors.Wrap(err, "decode ValidatorsSetListItem") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -37153,8 +42707,8 @@ func (s *Transactions) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfTransactions) { - name = jsonFieldsNameOfTransactions[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfValidatorsSetListItem) { + name = jsonFieldsNameOfValidatorsSetListItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -37175,98 +42729,44 @@ func (s *Transactions) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Transactions) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Transactions) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes TrustType as json. -func (s TrustType) Encode(e *jx.Encoder) { - e.Str(string(s)) -} - -// Decode decodes TrustType from json. -func (s *TrustType) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode TrustType to nil") - } - v, err := d.StrBytes() - if err != nil { - return err - } - // Try to use constant string. - switch TrustType(v) { - case TrustTypeWhitelist: - *s = TrustTypeWhitelist - case TrustTypeGraylist: - *s = TrustTypeGraylist - case TrustTypeBlacklist: - *s = TrustTypeBlacklist - case TrustTypeNone: - *s = TrustTypeNone - default: - *s = TrustType(v) - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s TrustType) MarshalJSON() ([]byte, error) { +func (s *ValidatorsSetListItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TrustType) UnmarshalJSON(data []byte) error { +func (s *ValidatorsSetListItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *TvmStackRecord) Encode(e *jx.Encoder) { +func (s *ValueFlow) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *TvmStackRecord) encodeFields(e *jx.Encoder) { - { - e.FieldStart("type") - s.Type.Encode(e) - } +func (s *ValueFlow) encodeFields(e *jx.Encoder) { { - if s.Cell.Set { - e.FieldStart("cell") - s.Cell.Encode(e) - } + e.FieldStart("account") + s.Account.Encode(e) } { - if s.Slice.Set { - e.FieldStart("slice") - s.Slice.Encode(e) - } + e.FieldStart("ton") + e.Int64(s.Ton) } { - if s.Num.Set { - e.FieldStart("num") - s.Num.Encode(e) - } + e.FieldStart("fees") + e.Int64(s.Fees) } { - if s.Tuple != nil { - e.FieldStart("tuple") + if s.Jettons != nil { + e.FieldStart("jettons") e.ArrStart() - for _, elem := range s.Tuple { + for _, elem := range s.Jettons { elem.Encode(e) } e.ArrEnd() @@ -37274,91 +42774,84 @@ func (s *TvmStackRecord) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfTvmStackRecord = [5]string{ - 0: "type", - 1: "cell", - 2: "slice", - 3: "num", - 4: "tuple", +var jsonFieldsNameOfValueFlow = [4]string{ + 0: "account", + 1: "ton", + 2: "fees", + 3: "jettons", } -// Decode decodes TvmStackRecord from json. -func (s *TvmStackRecord) Decode(d *jx.Decoder) error { +// Decode decodes ValueFlow from json. +func (s *ValueFlow) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode TvmStackRecord to nil") + return errors.New("invalid: unable to decode ValueFlow to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "type": + case "account": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Type.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"type\"") - } - case "cell": - if err := func() error { - s.Cell.Reset() - if err := s.Cell.Decode(d); err != nil { + if err := s.Account.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"cell\"") + return errors.Wrap(err, "decode field \"account\"") } - case "slice": + case "ton": + requiredBitSet[0] |= 1 << 1 if err := func() error { - s.Slice.Reset() - if err := s.Slice.Decode(d); err != nil { + v, err := d.Int64() + s.Ton = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"slice\"") + return errors.Wrap(err, "decode field \"ton\"") } - case "num": + case "fees": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Num.Reset() - if err := s.Num.Decode(d); err != nil { + v, err := d.Int64() + s.Fees = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"num\"") + return errors.Wrap(err, "decode field \"fees\"") } - case "tuple": + case "jettons": if err := func() error { - s.Tuple = make([]TvmStackRecord, 0) + s.Jettons = make([]ValueFlowJettonsItem, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem TvmStackRecord + var elem ValueFlowJettonsItem if err := elem.Decode(d); err != nil { return err } - s.Tuple = append(s.Tuple, elem) + s.Jettons = append(s.Jettons, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"tuple\"") + return errors.Wrap(err, "decode field \"jettons\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode TvmStackRecord") + return errors.Wrap(err, "decode ValueFlow") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -37370,8 +42863,8 @@ func (s *TvmStackRecord) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfTvmStackRecord) { - name = jsonFieldsNameOfTvmStackRecord[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfValueFlow) { + name = jsonFieldsNameOfValueFlow[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -37392,145 +42885,116 @@ func (s *TvmStackRecord) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *TvmStackRecord) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TvmStackRecord) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes TvmStackRecordType as json. -func (s TvmStackRecordType) Encode(e *jx.Encoder) { - e.Str(string(s)) -} - -// Decode decodes TvmStackRecordType from json. -func (s *TvmStackRecordType) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode TvmStackRecordType to nil") - } - v, err := d.StrBytes() - if err != nil { - return err - } - // Try to use constant string. - switch TvmStackRecordType(v) { - case TvmStackRecordTypeCell: - *s = TvmStackRecordTypeCell - case TvmStackRecordTypeNum: - *s = TvmStackRecordTypeNum - case TvmStackRecordTypeNan: - *s = TvmStackRecordTypeNan - case TvmStackRecordTypeNull: - *s = TvmStackRecordTypeNull - case TvmStackRecordTypeTuple: - *s = TvmStackRecordTypeTuple - default: - *s = TvmStackRecordType(v) - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s TvmStackRecordType) MarshalJSON() ([]byte, error) { +func (s *ValueFlow) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *TvmStackRecordType) UnmarshalJSON(data []byte) error { +func (s *ValueFlow) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *UnSubscriptionAction) Encode(e *jx.Encoder) { +func (s *ValueFlowJettonsItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *UnSubscriptionAction) encodeFields(e *jx.Encoder) { +func (s *ValueFlowJettonsItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("subscriber") - s.Subscriber.Encode(e) + e.FieldStart("account") + s.Account.Encode(e) } { - e.FieldStart("subscription") - e.Str(s.Subscription) + e.FieldStart("jetton") + s.Jetton.Encode(e) } { - e.FieldStart("beneficiary") - s.Beneficiary.Encode(e) + e.FieldStart("qty") + e.Str(s.Qty) + } + { + e.FieldStart("quantity") + e.Int64(s.Quantity) } } -var jsonFieldsNameOfUnSubscriptionAction = [3]string{ - 0: "subscriber", - 1: "subscription", - 2: "beneficiary", +var jsonFieldsNameOfValueFlowJettonsItem = [4]string{ + 0: "account", + 1: "jetton", + 2: "qty", + 3: "quantity", } -// Decode decodes UnSubscriptionAction from json. -func (s *UnSubscriptionAction) Decode(d *jx.Decoder) error { +// Decode decodes ValueFlowJettonsItem from json. +func (s *ValueFlowJettonsItem) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode UnSubscriptionAction to nil") + return errors.New("invalid: unable to decode ValueFlowJettonsItem to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "subscriber": + case "account": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Subscriber.Decode(d); err != nil { + if err := s.Account.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"subscriber\"") + return errors.Wrap(err, "decode field \"account\"") } - case "subscription": + case "jetton": requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Jetton.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"jetton\"") + } + case "qty": + requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.Subscription = string(v) + s.Qty = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"subscription\"") + return errors.Wrap(err, "decode field \"qty\"") } - case "beneficiary": - requiredBitSet[0] |= 1 << 2 + case "quantity": + requiredBitSet[0] |= 1 << 3 if err := func() error { - if err := s.Beneficiary.Decode(d); err != nil { + v, err := d.Int64() + s.Quantity = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"beneficiary\"") + return errors.Wrap(err, "decode field \"quantity\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode UnSubscriptionAction") + return errors.Wrap(err, "decode ValueFlowJettonsItem") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b00001111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -37542,8 +43006,8 @@ func (s *UnSubscriptionAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfUnSubscriptionAction) { - name = jsonFieldsNameOfUnSubscriptionAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfValueFlowJettonsItem) { + name = jsonFieldsNameOfValueFlowJettonsItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -37564,120 +43028,84 @@ func (s *UnSubscriptionAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *UnSubscriptionAction) MarshalJSON() ([]byte, error) { +func (s *ValueFlowJettonsItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *UnSubscriptionAction) UnmarshalJSON(data []byte) error { +func (s *ValueFlowJettonsItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Validator) Encode(e *jx.Encoder) { +func (s *VaultDepositInfo) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Validator) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } - { - e.FieldStart("adnl_address") - e.Str(s.AdnlAddress) - } +func (s *VaultDepositInfo) encodeFields(e *jx.Encoder) { { - e.FieldStart("stake") - e.Int64(s.Stake) + e.FieldStart("price") + s.Price.Encode(e) } { - e.FieldStart("max_factor") - e.Int64(s.MaxFactor) + e.FieldStart("vault") + e.Str(s.Vault) } } -var jsonFieldsNameOfValidator = [4]string{ - 0: "address", - 1: "adnl_address", - 2: "stake", - 3: "max_factor", +var jsonFieldsNameOfVaultDepositInfo = [2]string{ + 0: "price", + 1: "vault", } -// Decode decodes Validator from json. -func (s *Validator) Decode(d *jx.Decoder) error { +// Decode decodes VaultDepositInfo from json. +func (s *VaultDepositInfo) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Validator to nil") + return errors.New("invalid: unable to decode VaultDepositInfo to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "price": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Address = string(v) - if err != nil { + if err := s.Price.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") + return errors.Wrap(err, "decode field \"price\"") } - case "adnl_address": + case "vault": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.AdnlAddress = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"adnl_address\"") - } - case "stake": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Int64() - s.Stake = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"stake\"") - } - case "max_factor": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Int64() - s.MaxFactor = int64(v) + s.Vault = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"max_factor\"") + return errors.Wrap(err, "decode field \"vault\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Validator") + return errors.Wrap(err, "decode VaultDepositInfo") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001111, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -37689,8 +43117,8 @@ func (s *Validator) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfValidator) { - name = jsonFieldsNameOfValidator[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfVaultDepositInfo) { + name = jsonFieldsNameOfVaultDepositInfo[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -37711,147 +43139,322 @@ func (s *Validator) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Validator) MarshalJSON() ([]byte, error) { +func (s *VaultDepositInfo) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Validator) UnmarshalJSON(data []byte) error { +func (s *VaultDepositInfo) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Validators) Encode(e *jx.Encoder) { +func (s *Wallet) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Validators) encodeFields(e *jx.Encoder) { +func (s *Wallet) encodeFields(e *jx.Encoder) { { - e.FieldStart("elect_at") - e.Int64(s.ElectAt) + e.FieldStart("address") + e.Str(s.Address) } { - e.FieldStart("elect_close") - e.Int64(s.ElectClose) + e.FieldStart("is_wallet") + e.Bool(s.IsWallet) } { - e.FieldStart("min_stake") - e.Int64(s.MinStake) + e.FieldStart("balance") + e.Int64(s.Balance) } { - e.FieldStart("total_stake") - e.Int64(s.TotalStake) + e.FieldStart("stats") + s.Stats.Encode(e) } { - e.FieldStart("validators") + e.FieldStart("plugins") e.ArrStart() - for _, elem := range s.Validators { + for _, elem := range s.Plugins { elem.Encode(e) } e.ArrEnd() } + { + e.FieldStart("status") + s.Status.Encode(e) + } + { + e.FieldStart("last_activity") + e.Int64(s.LastActivity) + } + { + if s.Name.Set { + e.FieldStart("name") + s.Name.Encode(e) + } + } + { + if s.Icon.Set { + e.FieldStart("icon") + s.Icon.Encode(e) + } + } + { + e.FieldStart("get_methods") + e.ArrStart() + for _, elem := range s.GetMethods { + e.Str(elem) + } + e.ArrEnd() + } + { + if s.IsSuspended.Set { + e.FieldStart("is_suspended") + s.IsSuspended.Encode(e) + } + } + { + if s.SignatureDisabled.Set { + e.FieldStart("signature_disabled") + s.SignatureDisabled.Encode(e) + } + } + { + if s.Interfaces != nil { + e.FieldStart("interfaces") + e.ArrStart() + for _, elem := range s.Interfaces { + e.Str(elem) + } + e.ArrEnd() + } + } + { + e.FieldStart("last_lt") + e.Int64(s.LastLt) + } } -var jsonFieldsNameOfValidators = [5]string{ - 0: "elect_at", - 1: "elect_close", - 2: "min_stake", - 3: "total_stake", - 4: "validators", +var jsonFieldsNameOfWallet = [14]string{ + 0: "address", + 1: "is_wallet", + 2: "balance", + 3: "stats", + 4: "plugins", + 5: "status", + 6: "last_activity", + 7: "name", + 8: "icon", + 9: "get_methods", + 10: "is_suspended", + 11: "signature_disabled", + 12: "interfaces", + 13: "last_lt", } -// Decode decodes Validators from json. -func (s *Validators) Decode(d *jx.Decoder) error { +// Decode decodes Wallet from json. +func (s *Wallet) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Validators to nil") + return errors.New("invalid: unable to decode Wallet 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 "elect_at": + case "address": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.ElectAt = int64(v) + v, err := d.Str() + s.Address = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"elect_at\"") + return errors.Wrap(err, "decode field \"address\"") } - case "elect_close": + case "is_wallet": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int64() - s.ElectClose = int64(v) + v, err := d.Bool() + s.IsWallet = bool(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"elect_close\"") + return errors.Wrap(err, "decode field \"is_wallet\"") } - case "min_stake": + case "balance": requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Int64() - s.MinStake = int64(v) + s.Balance = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"min_stake\"") + return errors.Wrap(err, "decode field \"balance\"") } - case "total_stake": + case "stats": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Int64() - s.TotalStake = int64(v) - if err != nil { + if err := s.Stats.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"total_stake\"") + return errors.Wrap(err, "decode field \"stats\"") } - case "validators": + case "plugins": requiredBitSet[0] |= 1 << 4 if err := func() error { - s.Validators = make([]Validator, 0) + s.Plugins = make([]WalletPlugin, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem Validator + var elem WalletPlugin if err := elem.Decode(d); err != nil { return err } - s.Validators = append(s.Validators, elem) + s.Plugins = append(s.Plugins, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"validators\"") + return errors.Wrap(err, "decode field \"plugins\"") + } + case "status": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + if err := s.Status.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"status\"") + } + case "last_activity": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + v, err := d.Int64() + s.LastActivity = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"last_activity\"") + } + case "name": + if err := func() error { + s.Name.Reset() + if err := s.Name.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"name\"") + } + case "icon": + if err := func() error { + s.Icon.Reset() + if err := s.Icon.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"icon\"") + } + case "get_methods": + requiredBitSet[1] |= 1 << 1 + if err := func() error { + s.GetMethods = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.GetMethods = append(s.GetMethods, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"get_methods\"") + } + case "is_suspended": + if err := func() error { + s.IsSuspended.Reset() + if err := s.IsSuspended.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"is_suspended\"") + } + case "signature_disabled": + if err := func() error { + s.SignatureDisabled.Reset() + if err := s.SignatureDisabled.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"signature_disabled\"") + } + case "interfaces": + if err := func() error { + s.Interfaces = make([]string, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { + return err + } + s.Interfaces = append(s.Interfaces, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"interfaces\"") + } + case "last_lt": + requiredBitSet[1] |= 1 << 5 + if err := func() error { + v, err := d.Int64() + s.LastLt = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"last_lt\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Validators") + return errors.Wrap(err, "decode Wallet") } // Validate required fields. - var failures []validate.FieldError - for i, mask := range [1]uint8{ - 0b00011111, + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b01111111, + 0b00100010, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -37863,8 +43466,8 @@ func (s *Validators) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfValidators) { - name = jsonFieldsNameOfValidators[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfWallet) { + name = jsonFieldsNameOfWallet[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -37885,164 +43488,164 @@ func (s *Validators) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Validators) MarshalJSON() ([]byte, error) { +func (s *Wallet) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Validators) UnmarshalJSON(data []byte) error { +func (s *Wallet) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ValidatorsSet) Encode(e *jx.Encoder) { +func (s *WalletDNS) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ValidatorsSet) encodeFields(e *jx.Encoder) { +func (s *WalletDNS) encodeFields(e *jx.Encoder) { { - e.FieldStart("utime_since") - e.Int(s.UtimeSince) + e.FieldStart("address") + e.Str(s.Address) } { - e.FieldStart("utime_until") - e.Int(s.UtimeUntil) + e.FieldStart("account") + s.Account.Encode(e) } { - e.FieldStart("total") - e.Int(s.Total) + e.FieldStart("is_wallet") + e.Bool(s.IsWallet) } { - e.FieldStart("main") - e.Int(s.Main) + e.FieldStart("has_method_pubkey") + e.Bool(s.HasMethodPubkey) } { - if s.TotalWeight.Set { - e.FieldStart("total_weight") - s.TotalWeight.Encode(e) - } + e.FieldStart("has_method_seqno") + e.Bool(s.HasMethodSeqno) } { - e.FieldStart("list") + e.FieldStart("names") e.ArrStart() - for _, elem := range s.List { - elem.Encode(e) + for _, elem := range s.Names { + e.Str(elem) } e.ArrEnd() } } -var jsonFieldsNameOfValidatorsSet = [6]string{ - 0: "utime_since", - 1: "utime_until", - 2: "total", - 3: "main", - 4: "total_weight", - 5: "list", +var jsonFieldsNameOfWalletDNS = [6]string{ + 0: "address", + 1: "account", + 2: "is_wallet", + 3: "has_method_pubkey", + 4: "has_method_seqno", + 5: "names", } -// Decode decodes ValidatorsSet from json. -func (s *ValidatorsSet) Decode(d *jx.Decoder) error { +// Decode decodes WalletDNS from json. +func (s *WalletDNS) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ValidatorsSet to nil") + return errors.New("invalid: unable to decode WalletDNS to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "utime_since": + case "address": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int() - s.UtimeSince = int(v) + v, err := d.Str() + s.Address = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"utime_since\"") + return errors.Wrap(err, "decode field \"address\"") } - case "utime_until": + case "account": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int() - s.UtimeUntil = int(v) - if err != nil { + if err := s.Account.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"utime_until\"") + return errors.Wrap(err, "decode field \"account\"") } - case "total": + case "is_wallet": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Int() - s.Total = int(v) + v, err := d.Bool() + s.IsWallet = bool(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"total\"") + return errors.Wrap(err, "decode field \"is_wallet\"") } - case "main": + case "has_method_pubkey": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Int() - s.Main = int(v) + v, err := d.Bool() + s.HasMethodPubkey = bool(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"main\"") + return errors.Wrap(err, "decode field \"has_method_pubkey\"") } - case "total_weight": + case "has_method_seqno": + requiredBitSet[0] |= 1 << 4 if err := func() error { - s.TotalWeight.Reset() - if err := s.TotalWeight.Decode(d); err != nil { + v, err := d.Bool() + s.HasMethodSeqno = bool(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"total_weight\"") + return errors.Wrap(err, "decode field \"has_method_seqno\"") } - case "list": + case "names": requiredBitSet[0] |= 1 << 5 if err := func() error { - s.List = make([]ValidatorsSetListItem, 0) + s.Names = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem ValidatorsSetListItem - if err := elem.Decode(d); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } - s.List = append(s.List, elem) + s.Names = append(s.Names, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"list\"") + return errors.Wrap(err, "decode field \"names\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ValidatorsSet") + return errors.Wrap(err, "decode WalletDNS") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00101111, + 0b00111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -38054,8 +43657,8 @@ func (s *ValidatorsSet) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfValidatorsSet) { - name = jsonFieldsNameOfValidatorsSet[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfWalletDNS) { + name = jsonFieldsNameOfWalletDNS[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -38076,103 +43679,101 @@ func (s *ValidatorsSet) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ValidatorsSet) MarshalJSON() ([]byte, error) { +func (s *WalletDNS) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ValidatorsSet) UnmarshalJSON(data []byte) error { +func (s *WalletDNS) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ValidatorsSetListItem) Encode(e *jx.Encoder) { +func (s *WalletPlugin) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ValidatorsSetListItem) encodeFields(e *jx.Encoder) { +func (s *WalletPlugin) encodeFields(e *jx.Encoder) { { - e.FieldStart("public_key") - e.Str(s.PublicKey) + e.FieldStart("address") + e.Str(s.Address) } { - e.FieldStart("weight") - e.Int64(s.Weight) + e.FieldStart("type") + e.Str(s.Type) } { - if s.AdnlAddr.Set { - e.FieldStart("adnl_addr") - s.AdnlAddr.Encode(e) - } + e.FieldStart("status") + s.Status.Encode(e) } } -var jsonFieldsNameOfValidatorsSetListItem = [3]string{ - 0: "public_key", - 1: "weight", - 2: "adnl_addr", +var jsonFieldsNameOfWalletPlugin = [3]string{ + 0: "address", + 1: "type", + 2: "status", } -// Decode decodes ValidatorsSetListItem from json. -func (s *ValidatorsSetListItem) Decode(d *jx.Decoder) error { +// Decode decodes WalletPlugin from json. +func (s *WalletPlugin) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ValidatorsSetListItem to nil") + return errors.New("invalid: unable to decode WalletPlugin to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "public_key": + case "address": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.PublicKey = string(v) + s.Address = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"public_key\"") + return errors.Wrap(err, "decode field \"address\"") } - case "weight": + case "type": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int64() - s.Weight = int64(v) + v, err := d.Str() + s.Type = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"weight\"") + return errors.Wrap(err, "decode field \"type\"") } - case "adnl_addr": + case "status": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.AdnlAddr.Reset() - if err := s.AdnlAddr.Decode(d); err != nil { + if err := s.Status.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"adnl_addr\"") + return errors.Wrap(err, "decode field \"status\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ValidatorsSetListItem") + return errors.Wrap(err, "decode WalletPlugin") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000011, + 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -38184,8 +43785,8 @@ func (s *ValidatorsSetListItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfValidatorsSetListItem) { - name = jsonFieldsNameOfValidatorsSetListItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfWalletPlugin) { + name = jsonFieldsNameOfWalletPlugin[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -38206,129 +43807,120 @@ func (s *ValidatorsSetListItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ValidatorsSetListItem) MarshalJSON() ([]byte, error) { +func (s *WalletPlugin) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ValidatorsSetListItem) UnmarshalJSON(data []byte) error { +func (s *WalletPlugin) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ValueFlow) Encode(e *jx.Encoder) { +func (s *WalletStats) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ValueFlow) encodeFields(e *jx.Encoder) { +func (s *WalletStats) encodeFields(e *jx.Encoder) { { - e.FieldStart("account") - s.Account.Encode(e) + e.FieldStart("nfts_count") + e.Int32(s.NftsCount) } { - e.FieldStart("ton") - e.Int64(s.Ton) + e.FieldStart("jettons_count") + e.Int32(s.JettonsCount) } { - e.FieldStart("fees") - e.Int64(s.Fees) + e.FieldStart("multisig_count") + e.Int32(s.MultisigCount) } { - if s.Jettons != nil { - e.FieldStart("jettons") - e.ArrStart() - for _, elem := range s.Jettons { - elem.Encode(e) - } - e.ArrEnd() - } + e.FieldStart("staking_count") + e.Int32(s.StakingCount) } } -var jsonFieldsNameOfValueFlow = [4]string{ - 0: "account", - 1: "ton", - 2: "fees", - 3: "jettons", +var jsonFieldsNameOfWalletStats = [4]string{ + 0: "nfts_count", + 1: "jettons_count", + 2: "multisig_count", + 3: "staking_count", } -// Decode decodes ValueFlow from json. -func (s *ValueFlow) Decode(d *jx.Decoder) error { +// Decode decodes WalletStats from json. +func (s *WalletStats) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ValueFlow to nil") + return errors.New("invalid: unable to decode WalletStats to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "account": + case "nfts_count": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Account.Decode(d); err != nil { + v, err := d.Int32() + s.NftsCount = int32(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"account\"") + return errors.Wrap(err, "decode field \"nfts_count\"") } - case "ton": + case "jettons_count": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int64() - s.Ton = int64(v) + v, err := d.Int32() + s.JettonsCount = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ton\"") + return errors.Wrap(err, "decode field \"jettons_count\"") } - case "fees": + case "multisig_count": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Int64() - s.Fees = int64(v) + v, err := d.Int32() + s.MultisigCount = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"fees\"") + return errors.Wrap(err, "decode field \"multisig_count\"") } - case "jettons": + case "staking_count": + requiredBitSet[0] |= 1 << 3 if err := func() error { - s.Jettons = make([]ValueFlowJettonsItem, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem ValueFlowJettonsItem - if err := elem.Decode(d); err != nil { - return err - } - s.Jettons = append(s.Jettons, elem) - return nil - }); err != nil { + v, err := d.Int32() + s.StakingCount = int32(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"jettons\"") + return errors.Wrap(err, "decode field \"staking_count\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ValueFlow") + return errors.Wrap(err, "decode WalletStats") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b00001111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -38340,8 +43932,8 @@ func (s *ValueFlow) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfValueFlow) { - name = jsonFieldsNameOfValueFlow[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfWalletStats) { + name = jsonFieldsNameOfWalletStats[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -38362,99 +43954,79 @@ func (s *ValueFlow) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ValueFlow) MarshalJSON() ([]byte, error) { +func (s *WalletStats) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ValueFlow) UnmarshalJSON(data []byte) error { +func (s *WalletStats) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ValueFlowJettonsItem) Encode(e *jx.Encoder) { +func (s *Wallets) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ValueFlowJettonsItem) encodeFields(e *jx.Encoder) { +func (s *Wallets) encodeFields(e *jx.Encoder) { { - e.FieldStart("account") - s.Account.Encode(e) - } - { - e.FieldStart("jetton") - s.Jetton.Encode(e) - } - { - e.FieldStart("quantity") - e.Int64(s.Quantity) + e.FieldStart("accounts") + e.ArrStart() + for _, elem := range s.Accounts { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfValueFlowJettonsItem = [3]string{ - 0: "account", - 1: "jetton", - 2: "quantity", +var jsonFieldsNameOfWallets = [1]string{ + 0: "accounts", } -// Decode decodes ValueFlowJettonsItem from json. -func (s *ValueFlowJettonsItem) Decode(d *jx.Decoder) error { +// Decode decodes Wallets from json. +func (s *Wallets) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ValueFlowJettonsItem to nil") + return errors.New("invalid: unable to decode Wallets to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "account": + case "accounts": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Account.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"account\"") - } - case "jetton": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - if err := s.Jetton.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"jetton\"") - } - case "quantity": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Int64() - s.Quantity = int64(v) - if err != nil { + s.Accounts = make([]Wallet, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem Wallet + if err := elem.Decode(d); err != nil { + return err + } + s.Accounts = append(s.Accounts, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"quantity\"") + return errors.Wrap(err, "decode field \"accounts\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ValueFlowJettonsItem") + return errors.Wrap(err, "decode Wallets") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -38466,8 +44038,8 @@ func (s *ValueFlowJettonsItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfValueFlowJettonsItem) { - name = jsonFieldsNameOfValueFlowJettonsItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfWallets) { + name = jsonFieldsNameOfWallets[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -38488,164 +44060,114 @@ func (s *ValueFlowJettonsItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ValueFlowJettonsItem) MarshalJSON() ([]byte, error) { +func (s *Wallets) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ValueFlowJettonsItem) UnmarshalJSON(data []byte) error { +func (s *Wallets) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *WalletDNS) Encode(e *jx.Encoder) { +func (s *WithdrawStakeAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *WalletDNS) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } - { - e.FieldStart("account") - s.Account.Encode(e) - } +func (s *WithdrawStakeAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("is_wallet") - e.Bool(s.IsWallet) + e.FieldStart("amount") + e.Int64(s.Amount) } { - e.FieldStart("has_method_pubkey") - e.Bool(s.HasMethodPubkey) + e.FieldStart("staker") + s.Staker.Encode(e) } { - e.FieldStart("has_method_seqno") - e.Bool(s.HasMethodSeqno) + e.FieldStart("pool") + s.Pool.Encode(e) } { - e.FieldStart("names") - e.ArrStart() - for _, elem := range s.Names { - e.Str(elem) - } - e.ArrEnd() + e.FieldStart("implementation") + s.Implementation.Encode(e) } } -var jsonFieldsNameOfWalletDNS = [6]string{ - 0: "address", - 1: "account", - 2: "is_wallet", - 3: "has_method_pubkey", - 4: "has_method_seqno", - 5: "names", +var jsonFieldsNameOfWithdrawStakeAction = [4]string{ + 0: "amount", + 1: "staker", + 2: "pool", + 3: "implementation", } -// Decode decodes WalletDNS from json. -func (s *WalletDNS) Decode(d *jx.Decoder) error { +// Decode decodes WithdrawStakeAction from json. +func (s *WithdrawStakeAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode WalletDNS to nil") + return errors.New("invalid: unable to decode WithdrawStakeAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "amount": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Address = string(v) + v, err := d.Int64() + s.Amount = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") + return errors.Wrap(err, "decode field \"amount\"") } - case "account": + case "staker": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Account.Decode(d); err != nil { + if err := s.Staker.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"account\"") + return errors.Wrap(err, "decode field \"staker\"") } - case "is_wallet": + case "pool": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Bool() - s.IsWallet = bool(v) - if err != nil { + if err := s.Pool.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"is_wallet\"") + return errors.Wrap(err, "decode field \"pool\"") } - case "has_method_pubkey": + case "implementation": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Bool() - s.HasMethodPubkey = bool(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"has_method_pubkey\"") - } - case "has_method_seqno": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Bool() - s.HasMethodSeqno = bool(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"has_method_seqno\"") - } - case "names": - requiredBitSet[0] |= 1 << 5 - if err := func() error { - s.Names = make([]string, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { - return err - } - s.Names = append(s.Names, elem) - return nil - }); err != nil { + if err := s.Implementation.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"names\"") + return errors.Wrap(err, "decode field \"implementation\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode WalletDNS") + return errors.Wrap(err, "decode WithdrawStakeAction") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00111111, + 0b00001111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -38657,8 +44179,8 @@ func (s *WalletDNS) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfWalletDNS) { - name = jsonFieldsNameOfWalletDNS[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfWithdrawStakeAction) { + name = jsonFieldsNameOfWithdrawStakeAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -38679,30 +44201,32 @@ func (s *WalletDNS) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *WalletDNS) MarshalJSON() ([]byte, error) { +func (s *WithdrawStakeAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *WalletDNS) UnmarshalJSON(data []byte) error { +func (s *WithdrawStakeAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *WithdrawStakeAction) Encode(e *jx.Encoder) { +func (s *WithdrawStakeRequestAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *WithdrawStakeAction) encodeFields(e *jx.Encoder) { +func (s *WithdrawStakeRequestAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("amount") - e.Int64(s.Amount) + if s.Amount.Set { + e.FieldStart("amount") + s.Amount.Encode(e) + } } { e.FieldStart("staker") @@ -38718,28 +44242,26 @@ func (s *WithdrawStakeAction) encodeFields(e *jx.Encoder) { } } -var jsonFieldsNameOfWithdrawStakeAction = [4]string{ +var jsonFieldsNameOfWithdrawStakeRequestAction = [4]string{ 0: "amount", 1: "staker", 2: "pool", 3: "implementation", } -// Decode decodes WithdrawStakeAction from json. -func (s *WithdrawStakeAction) Decode(d *jx.Decoder) error { +// Decode decodes WithdrawStakeRequestAction from json. +func (s *WithdrawStakeRequestAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode WithdrawStakeAction to nil") + return errors.New("invalid: unable to decode WithdrawStakeRequestAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { case "amount": - requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.Amount = int64(v) - if err != nil { + s.Amount.Reset() + if err := s.Amount.Decode(d); err != nil { return err } return nil @@ -38781,12 +44303,12 @@ func (s *WithdrawStakeAction) Decode(d *jx.Decoder) error { } return nil }); err != nil { - return errors.Wrap(err, "decode WithdrawStakeAction") + return errors.Wrap(err, "decode WithdrawStakeRequestAction") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001111, + 0b00001110, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -38798,8 +44320,8 @@ func (s *WithdrawStakeAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfWithdrawStakeAction) { - name = jsonFieldsNameOfWithdrawStakeAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfWithdrawStakeRequestAction) { + name = jsonFieldsNameOfWithdrawStakeRequestAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -38820,75 +44342,60 @@ func (s *WithdrawStakeAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *WithdrawStakeAction) MarshalJSON() ([]byte, error) { +func (s *WithdrawStakeRequestAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *WithdrawStakeAction) UnmarshalJSON(data []byte) error { +func (s *WithdrawStakeRequestAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *WithdrawStakeRequestAction) Encode(e *jx.Encoder) { +func (s *WithdrawTokenStakeRequestAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *WithdrawStakeRequestAction) encodeFields(e *jx.Encoder) { - { - if s.Amount.Set { - e.FieldStart("amount") - s.Amount.Encode(e) - } - } +func (s *WithdrawTokenStakeRequestAction) encodeFields(e *jx.Encoder) { { e.FieldStart("staker") s.Staker.Encode(e) } { - e.FieldStart("pool") - s.Pool.Encode(e) + e.FieldStart("protocol") + s.Protocol.Encode(e) } { - e.FieldStart("implementation") - s.Implementation.Encode(e) + if s.StakeMeta.Set { + e.FieldStart("stake_meta") + s.StakeMeta.Encode(e) + } } } -var jsonFieldsNameOfWithdrawStakeRequestAction = [4]string{ - 0: "amount", - 1: "staker", - 2: "pool", - 3: "implementation", +var jsonFieldsNameOfWithdrawTokenStakeRequestAction = [3]string{ + 0: "staker", + 1: "protocol", + 2: "stake_meta", } -// Decode decodes WithdrawStakeRequestAction from json. -func (s *WithdrawStakeRequestAction) Decode(d *jx.Decoder) error { +// Decode decodes WithdrawTokenStakeRequestAction from json. +func (s *WithdrawTokenStakeRequestAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode WithdrawStakeRequestAction to nil") + return errors.New("invalid: unable to decode WithdrawTokenStakeRequestAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "amount": - if err := func() error { - s.Amount.Reset() - if err := s.Amount.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") - } case "staker": - requiredBitSet[0] |= 1 << 1 + requiredBitSet[0] |= 1 << 0 if err := func() error { if err := s.Staker.Decode(d); err != nil { return err @@ -38897,37 +44404,37 @@ func (s *WithdrawStakeRequestAction) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"staker\"") } - case "pool": - requiredBitSet[0] |= 1 << 2 + case "protocol": + requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Pool.Decode(d); err != nil { + if err := s.Protocol.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"pool\"") + return errors.Wrap(err, "decode field \"protocol\"") } - case "implementation": - requiredBitSet[0] |= 1 << 3 + case "stake_meta": if err := func() error { - if err := s.Implementation.Decode(d); err != nil { + s.StakeMeta.Reset() + if err := s.StakeMeta.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"implementation\"") + return errors.Wrap(err, "decode field \"stake_meta\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode WithdrawStakeRequestAction") + return errors.Wrap(err, "decode WithdrawTokenStakeRequestAction") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001110, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -38939,8 +44446,8 @@ func (s *WithdrawStakeRequestAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfWithdrawStakeRequestAction) { - name = jsonFieldsNameOfWithdrawStakeRequestAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfWithdrawTokenStakeRequestAction) { + name = jsonFieldsNameOfWithdrawTokenStakeRequestAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -38961,14 +44468,14 @@ func (s *WithdrawStakeRequestAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *WithdrawStakeRequestAction) MarshalJSON() ([]byte, error) { +func (s *WithdrawTokenStakeRequestAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *WithdrawStakeRequestAction) UnmarshalJSON(data []byte) error { +func (s *WithdrawTokenStakeRequestAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } diff --git a/oas_operations_gen.go b/oas_operations_gen.go new file mode 100644 index 0000000..2ca4ea0 --- /dev/null +++ b/oas_operations_gen.go @@ -0,0 +1,117 @@ +// Code generated by ogen, DO NOT EDIT. + +package tonapi + +// OperationName is the ogen operation name +type OperationName = string + +const ( + AccountDnsBackResolveOperation OperationName = "AccountDnsBackResolve" + AddressParseOperation OperationName = "AddressParse" + BlockchainAccountInspectOperation OperationName = "BlockchainAccountInspect" + DecodeMessageOperation OperationName = "DecodeMessage" + DnsResolveOperation OperationName = "DnsResolve" + DownloadBlockchainBlockBocOperation OperationName = "DownloadBlockchainBlockBoc" + EmulateMessageToAccountEventOperation OperationName = "EmulateMessageToAccountEvent" + EmulateMessageToEventOperation OperationName = "EmulateMessageToEvent" + EmulateMessageToTraceOperation OperationName = "EmulateMessageToTrace" + EmulateMessageToWalletOperation OperationName = "EmulateMessageToWallet" + ExecGetMethodForBlockchainAccountOperation OperationName = "ExecGetMethodForBlockchainAccount" + ExecGetMethodWithBodyForBlockchainAccountOperation OperationName = "ExecGetMethodWithBodyForBlockchainAccount" + GaslessConfigOperation OperationName = "GaslessConfig" + GaslessEstimateOperation OperationName = "GaslessEstimate" + GaslessSendOperation OperationName = "GaslessSend" + GetAccountOperation OperationName = "GetAccount" + GetAccountDiffOperation OperationName = "GetAccountDiff" + GetAccountDnsExpiringOperation OperationName = "GetAccountDnsExpiring" + GetAccountEventOperation OperationName = "GetAccountEvent" + GetAccountEventsOperation OperationName = "GetAccountEvents" + GetAccountExtraCurrencyHistoryByIDOperation OperationName = "GetAccountExtraCurrencyHistoryByID" + GetAccountInfoByStateInitOperation OperationName = "GetAccountInfoByStateInit" + GetAccountJettonBalanceOperation OperationName = "GetAccountJettonBalance" + GetAccountJettonHistoryByIDOperation OperationName = "GetAccountJettonHistoryByID" + GetAccountJettonsBalancesOperation OperationName = "GetAccountJettonsBalances" + GetAccountJettonsHistoryOperation OperationName = "GetAccountJettonsHistory" + GetAccountMultisigsOperation OperationName = "GetAccountMultisigs" + GetAccountNftHistoryOperation OperationName = "GetAccountNftHistory" + GetAccountNftItemsOperation OperationName = "GetAccountNftItems" + GetAccountNominatorsPoolsOperation OperationName = "GetAccountNominatorsPools" + GetAccountPublicKeyOperation OperationName = "GetAccountPublicKey" + GetAccountSeqnoOperation OperationName = "GetAccountSeqno" + GetAccountSubscriptionsOperation OperationName = "GetAccountSubscriptions" + GetAccountTracesOperation OperationName = "GetAccountTraces" + GetAccountsOperation OperationName = "GetAccounts" + GetAllAuctionsOperation OperationName = "GetAllAuctions" + GetAllRawShardsInfoOperation OperationName = "GetAllRawShardsInfo" + GetBlockchainAccountTransactionsOperation OperationName = "GetBlockchainAccountTransactions" + GetBlockchainBlockOperation OperationName = "GetBlockchainBlock" + GetBlockchainBlockTransactionsOperation OperationName = "GetBlockchainBlockTransactions" + GetBlockchainConfigOperation OperationName = "GetBlockchainConfig" + GetBlockchainConfigFromBlockOperation OperationName = "GetBlockchainConfigFromBlock" + GetBlockchainMasterchainBlocksOperation OperationName = "GetBlockchainMasterchainBlocks" + GetBlockchainMasterchainHeadOperation OperationName = "GetBlockchainMasterchainHead" + GetBlockchainMasterchainShardsOperation OperationName = "GetBlockchainMasterchainShards" + GetBlockchainMasterchainTransactionsOperation OperationName = "GetBlockchainMasterchainTransactions" + GetBlockchainRawAccountOperation OperationName = "GetBlockchainRawAccount" + GetBlockchainTransactionOperation OperationName = "GetBlockchainTransaction" + GetBlockchainTransactionByMessageHashOperation OperationName = "GetBlockchainTransactionByMessageHash" + GetBlockchainValidatorsOperation OperationName = "GetBlockchainValidators" + GetChartRatesOperation OperationName = "GetChartRates" + GetDnsInfoOperation OperationName = "GetDnsInfo" + GetDomainBidsOperation OperationName = "GetDomainBids" + GetEventOperation OperationName = "GetEvent" + GetExtraCurrencyInfoOperation OperationName = "GetExtraCurrencyInfo" + GetItemsFromCollectionOperation OperationName = "GetItemsFromCollection" + GetJettonAccountHistoryByIDOperation OperationName = "GetJettonAccountHistoryByID" + GetJettonHoldersOperation OperationName = "GetJettonHolders" + GetJettonInfoOperation OperationName = "GetJettonInfo" + GetJettonInfosByAddressesOperation OperationName = "GetJettonInfosByAddresses" + GetJettonTransferPayloadOperation OperationName = "GetJettonTransferPayload" + GetJettonsOperation OperationName = "GetJettons" + GetJettonsEventsOperation OperationName = "GetJettonsEvents" + GetLibraryByHashOperation OperationName = "GetLibraryByHash" + GetMarketsRatesOperation OperationName = "GetMarketsRates" + GetMultisigAccountOperation OperationName = "GetMultisigAccount" + GetMultisigOrderOperation OperationName = "GetMultisigOrder" + GetNftCollectionOperation OperationName = "GetNftCollection" + GetNftCollectionItemsByAddressesOperation OperationName = "GetNftCollectionItemsByAddresses" + GetNftCollectionsOperation OperationName = "GetNftCollections" + GetNftHistoryByIDOperation OperationName = "GetNftHistoryByID" + GetNftItemByAddressOperation OperationName = "GetNftItemByAddress" + GetNftItemsByAddressesOperation OperationName = "GetNftItemsByAddresses" + GetOpenapiJsonOperation OperationName = "GetOpenapiJson" + GetOpenapiYmlOperation OperationName = "GetOpenapiYml" + GetOutMsgQueueSizesOperation OperationName = "GetOutMsgQueueSizes" + GetPurchaseHistoryOperation OperationName = "GetPurchaseHistory" + GetRatesOperation OperationName = "GetRates" + GetRawAccountStateOperation OperationName = "GetRawAccountState" + GetRawBlockProofOperation OperationName = "GetRawBlockProof" + GetRawBlockchainBlockOperation OperationName = "GetRawBlockchainBlock" + GetRawBlockchainBlockHeaderOperation OperationName = "GetRawBlockchainBlockHeader" + GetRawBlockchainBlockStateOperation OperationName = "GetRawBlockchainBlockState" + GetRawBlockchainConfigOperation OperationName = "GetRawBlockchainConfig" + GetRawBlockchainConfigFromBlockOperation OperationName = "GetRawBlockchainConfigFromBlock" + GetRawConfigOperation OperationName = "GetRawConfig" + GetRawListBlockTransactionsOperation OperationName = "GetRawListBlockTransactions" + GetRawMasterchainInfoOperation OperationName = "GetRawMasterchainInfo" + GetRawMasterchainInfoExtOperation OperationName = "GetRawMasterchainInfoExt" + GetRawShardBlockProofOperation OperationName = "GetRawShardBlockProof" + GetRawShardInfoOperation OperationName = "GetRawShardInfo" + GetRawTimeOperation OperationName = "GetRawTime" + GetRawTransactionsOperation OperationName = "GetRawTransactions" + GetReducedBlockchainBlocksOperation OperationName = "GetReducedBlockchainBlocks" + GetStakingPoolHistoryOperation OperationName = "GetStakingPoolHistory" + GetStakingPoolInfoOperation OperationName = "GetStakingPoolInfo" + GetStakingPoolsOperation OperationName = "GetStakingPools" + GetStorageProvidersOperation OperationName = "GetStorageProviders" + GetTonConnectPayloadOperation OperationName = "GetTonConnectPayload" + GetTraceOperation OperationName = "GetTrace" + GetWalletInfoOperation OperationName = "GetWalletInfo" + GetWalletsByPublicKeyOperation OperationName = "GetWalletsByPublicKey" + ReindexAccountOperation OperationName = "ReindexAccount" + SearchAccountsOperation OperationName = "SearchAccounts" + SendBlockchainMessageOperation OperationName = "SendBlockchainMessage" + SendRawMessageOperation OperationName = "SendRawMessage" + StatusOperation OperationName = "Status" + TonConnectProofOperation OperationName = "TonConnectProof" +) diff --git a/oas_parameters_gen.go b/oas_parameters_gen.go index a0ed28a..0f67095 100644 --- a/oas_parameters_gen.go +++ b/oas_parameters_gen.go @@ -24,6 +24,13 @@ type BlockchainAccountInspectParams struct { type DnsResolveParams struct { // Domain name with .ton or .t.me. DomainName string + Filter OptBool +} + +// DownloadBlockchainBlockBocParams is parameters of downloadBlockchainBlockBoc operation. +type DownloadBlockchainBlockBocParams struct { + // Block ID. + BlockID string } // EmulateMessageToAccountEventParams is parameters of emulateMessageToAccountEvent operation. @@ -48,6 +55,7 @@ type EmulateMessageToTraceParams struct { // EmulateMessageToWalletParams is parameters of emulateMessageToWallet operation. type EmulateMessageToWalletParams struct { AcceptLanguage OptString + Currency OptString } // ExecGetMethodForBlockchainAccountParams is parameters of execGetMethodForBlockchainAccount operation. @@ -59,8 +67,17 @@ type ExecGetMethodForBlockchainAccountParams struct { Args []string } +// ExecGetMethodWithBodyForBlockchainAccountParams is parameters of execGetMethodWithBodyForBlockchainAccount operation. +type ExecGetMethodWithBodyForBlockchainAccountParams struct { + // Account ID. + AccountID string + // Contract get method name. + MethodName string +} + // GaslessEstimateParams is parameters of gaslessEstimate operation. type GaslessEstimateParams struct { + AcceptLanguage OptString // Jetton to pay commission. MasterID string } @@ -114,33 +131,18 @@ type GetAccountEventsParams struct { EndDate OptInt64 } -// GetAccountInscriptionsParams is parameters of getAccountInscriptions operation. -type GetAccountInscriptionsParams struct { +// GetAccountExtraCurrencyHistoryByIDParams is parameters of getAccountExtraCurrencyHistoryByID operation. +type GetAccountExtraCurrencyHistoryByIDParams struct { // Account ID. AccountID string - Limit OptInt - Offset OptInt -} - -// GetAccountInscriptionsHistoryParams is parameters of getAccountInscriptionsHistory operation. -type GetAccountInscriptionsHistoryParams struct { - // Account ID. - AccountID string + // Extra currency id. + ID int32 AcceptLanguage OptString // Omit this parameter to get last events. - BeforeLt OptInt64 - Limit OptInt -} - -// GetAccountInscriptionsHistoryByTickerParams is parameters of getAccountInscriptionsHistoryByTicker operation. -type GetAccountInscriptionsHistoryByTickerParams struct { - // Account ID. - AccountID string - AcceptLanguage OptString - Ticker string - // Omit this parameter to get last events. - BeforeLt OptInt64 - Limit OptInt + BeforeLt OptInt64 + Limit int + StartDate OptInt64 + EndDate OptInt64 } // GetAccountJettonBalanceParams is parameters of getAccountJettonBalance operation. @@ -151,6 +153,8 @@ type GetAccountJettonBalanceParams struct { JettonID string // Accept ton and all possible fiat currencies, separated by commas. Currencies []string + // Comma separated list supported extensions. + SupportedExtensions []string } // GetAccountJettonHistoryByIDParams is parameters of getAccountJettonHistoryByID operation. @@ -180,13 +184,10 @@ type GetAccountJettonsBalancesParams struct { // GetAccountJettonsHistoryParams is parameters of getAccountJettonsHistory operation. type GetAccountJettonsHistoryParams struct { // Account ID. - AccountID string - AcceptLanguage OptString + AccountID string // Omit this parameter to get last events. - BeforeLt OptInt64 - Limit int - StartDate OptInt64 - EndDate OptInt64 + BeforeLt OptInt64 + Limit int } // GetAccountMultisigsParams is parameters of getAccountMultisigs operation. @@ -201,10 +202,8 @@ type GetAccountNftHistoryParams struct { AccountID string AcceptLanguage OptString // Omit this parameter to get last events. - BeforeLt OptInt64 - Limit int - StartDate OptInt64 - EndDate OptInt64 + BeforeLt OptInt64 + Limit int } // GetAccountNftItemsParams is parameters of getAccountNftItems operation. @@ -365,15 +364,10 @@ type GetEventParams struct { AcceptLanguage OptString } -// GetInscriptionOpTemplateParams is parameters of getInscriptionOpTemplate operation. -type GetInscriptionOpTemplateParams struct { - Type GetInscriptionOpTemplateType - Destination OptString - Comment OptString - Operation GetInscriptionOpTemplateOperation - Amount string - Ticker string - Who string +// GetExtraCurrencyInfoParams is parameters of getExtraCurrencyInfo operation. +type GetExtraCurrencyInfoParams struct { + // Extra currency id. + ID int32 } // GetItemsFromCollectionParams is parameters of getItemsFromCollection operation. @@ -384,6 +378,19 @@ type GetItemsFromCollectionParams struct { Offset OptInt } +// GetJettonAccountHistoryByIDParams is parameters of getJettonAccountHistoryByID operation. +type GetJettonAccountHistoryByIDParams struct { + // Account ID. + AccountID string + // Jetton ID. + JettonID string + // Omit this parameter to get last events. + BeforeLt OptInt64 + Limit int + StartDate OptInt64 + EndDate OptInt64 +} + // GetJettonHoldersParams is parameters of getJettonHolders operation. type GetJettonHoldersParams struct { // Account ID. @@ -419,12 +426,24 @@ type GetJettonsEventsParams struct { AcceptLanguage OptString } +// GetLibraryByHashParams is parameters of getLibraryByHash operation. +type GetLibraryByHashParams struct { + // Hash in hex (without 0x) format. + Hash string +} + // GetMultisigAccountParams is parameters of getMultisigAccount operation. type GetMultisigAccountParams struct { // Account ID. AccountID string } +// GetMultisigOrderParams is parameters of getMultisigOrder operation. +type GetMultisigOrderParams struct { + // Account ID. + AccountID string +} + // GetNftCollectionParams is parameters of getNftCollection operation. type GetNftCollectionParams struct { // Account ID. @@ -455,6 +474,15 @@ type GetNftItemByAddressParams struct { AccountID string } +// GetPurchaseHistoryParams is parameters of getPurchaseHistory operation. +type GetPurchaseHistoryParams struct { + // Account ID. + AccountID string + // Omit this parameter to get last invoices. + BeforeLt OptInt64 + Limit OptInt +} + // GetRatesParams is parameters of getRates operation. type GetRatesParams struct { // Accept ton and jetton master addresses, separated by commas. @@ -599,9 +627,10 @@ type GetTraceParams struct { TraceID string } -// GetWalletBackupParams is parameters of getWalletBackup operation. -type GetWalletBackupParams struct { - XTonConnectAuth string +// GetWalletInfoParams is parameters of getWalletInfo operation. +type GetWalletInfoParams struct { + // Account ID. + AccountID string } // GetWalletsByPublicKeyParams is parameters of getWalletsByPublicKey operation. @@ -619,8 +648,3 @@ type ReindexAccountParams struct { type SearchAccountsParams struct { Name string } - -// SetWalletBackupParams is parameters of setWalletBackup operation. -type SetWalletBackupParams struct { - XTonConnectAuth string -} diff --git a/oas_request_encoders_gen.go b/oas_request_encoders_gen.go index 2939a12..0c955e3 100644 --- a/oas_request_encoders_gen.go +++ b/oas_request_encoders_gen.go @@ -81,6 +81,26 @@ func encodeEmulateMessageToWalletRequest( return nil } +func encodeExecGetMethodWithBodyForBlockchainAccountRequest( + req OptExecGetMethodWithBodyForBlockchainAccountReq, + r *http.Request, +) error { + const contentType = "application/json" + if !req.Set { + // Keep request with empty body if value is not set. + return nil + } + e := new(jx.Encoder) + { + if req.Set { + req.Encode(e) + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + func encodeGaslessEstimateRequest( req *GaslessEstimateReq, r *http.Request, @@ -143,6 +163,46 @@ func encodeGetAccountsRequest( return nil } +func encodeGetJettonInfosByAddressesRequest( + req OptGetJettonInfosByAddressesReq, + r *http.Request, +) error { + const contentType = "application/json" + if !req.Set { + // Keep request with empty body if value is not set. + return nil + } + e := new(jx.Encoder) + { + if req.Set { + req.Encode(e) + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodeGetNftCollectionItemsByAddressesRequest( + req OptGetNftCollectionItemsByAddressesReq, + r *http.Request, +) error { + const contentType = "application/json" + if !req.Set { + // Keep request with empty body if value is not set. + return nil + } + e := new(jx.Encoder) + { + if req.Set { + req.Encode(e) + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + func encodeGetNftItemsByAddressesRequest( req OptGetNftItemsByAddressesReq, r *http.Request, @@ -191,16 +251,6 @@ func encodeSendRawMessageRequest( return nil } -func encodeSetWalletBackupRequest( - req SetWalletBackupReq, - r *http.Request, -) error { - const contentType = "application/octet-stream" - body := req - ht.SetBody(r, body, contentType) - return nil -} - func encodeTonConnectProofRequest( req *TonConnectProofReq, r *http.Request, diff --git a/oas_response_decoders_gen.go b/oas_response_decoders_gen.go index 41feb6c..73928d6 100644 --- a/oas_response_decoders_gen.go +++ b/oas_response_decoders_gen.go @@ -3,6 +3,7 @@ package tonapi import ( + "bytes" "io" "mime" "net/http" @@ -10,7 +11,9 @@ import ( "github.com/go-faster/errors" "github.com/go-faster/jx" + "github.com/ogen-go/ogen/conv" "github.com/ogen-go/ogen/ogenerrors" + "github.com/ogen-go/ogen/uri" "github.com/ogen-go/ogen/validate" ) @@ -47,6 +50,757 @@ func decodeAccountDnsBackResolveResponse(resp *http.Response) (res *DomainNames, } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + 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 decodeAddressParseResponse(resp *http.Response) (res *AddressParseOK, _ 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 AddressParseOK + 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 decodeBlockchainAccountInspectResponse(resp *http.Response) (res *BlockchainAccountInspect, _ 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 BlockchainAccountInspect + 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 + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + 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 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 + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + 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: + // 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 DnsRecord + 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 + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + 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 decodeDownloadBlockchainBlockBocResponse(resp *http.Response) (res *DownloadBlockchainBlockBocOKHeaders, _ 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/octet-stream": + reader := resp.Body + b, err := io.ReadAll(reader) + if err != nil { + return res, err + } + + response := DownloadBlockchainBlockBocOK{Data: bytes.NewReader(b)} + var wrapper DownloadBlockchainBlockBocOKHeaders + wrapper.Response = response + h := uri.NewHeaderDecoder(resp.Header) + // Parse "Content-Disposition" header. + { + cfg := uri.HeaderParameterDecodingConfig{ + Name: "Content-Disposition", + Explode: false, + } + if err := func() error { + if err := h.HasParam(cfg); err == nil { + if err := h.DecodeParam(cfg, func(d uri.Decoder) error { + var wrapperDotContentDispositionVal string + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToString(val) + if err != nil { + return err + } + + wrapperDotContentDispositionVal = c + return nil + }(); err != nil { + return err + } + wrapper.ContentDisposition.SetTo(wrapperDotContentDispositionVal) + return nil + }); err != nil { + return err + } + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "parse Content-Disposition header") + } + } + return &wrapper, 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 decodeEmulateMessageToAccountEventResponse(resp *http.Response) (res *AccountEvent, _ 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 AccountEvent + 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 + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + 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 decodeEmulateMessageToEventResponse(resp *http.Response) (res *Event, _ 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 Event + 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 + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + 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 decodeEmulateMessageToTraceResponse(resp *http.Response) (res *Trace, _ 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 Trace + 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 + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -97,7 +851,7 @@ func decodeAccountDnsBackResolveResponse(resp *http.Response) (res *DomainNames, return res, errors.Wrap(defRes, "error") } -func decodeAddressParseResponse(resp *http.Response) (res *AddressParseOK, _ error) { +func decodeEmulateMessageToWalletResponse(resp *http.Response) (res *MessageConsequences, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -113,7 +867,7 @@ func decodeAddressParseResponse(resp *http.Response) (res *AddressParseOK, _ err } d := jx.DecodeBytes(buf) - var response AddressParseOK + var response MessageConsequences if err := func() error { if err := response.Decode(d); err != nil { return err @@ -130,6 +884,15 @@ func decodeAddressParseResponse(resp *http.Response) (res *AddressParseOK, _ err } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -180,7 +943,7 @@ func decodeAddressParseResponse(resp *http.Response) (res *AddressParseOK, _ err return res, errors.Wrap(defRes, "error") } -func decodeBlockchainAccountInspectResponse(resp *http.Response) (res *BlockchainAccountInspect, _ error) { +func decodeExecGetMethodForBlockchainAccountResponse(resp *http.Response) (res *MethodExecutionResult, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -196,7 +959,7 @@ func decodeBlockchainAccountInspectResponse(resp *http.Response) (res *Blockchai } d := jx.DecodeBytes(buf) - var response BlockchainAccountInspect + var response MethodExecutionResult if err := func() error { if err := response.Decode(d); err != nil { return err @@ -213,6 +976,15 @@ func decodeBlockchainAccountInspectResponse(resp *http.Response) (res *Blockchai } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -263,7 +1035,7 @@ func decodeBlockchainAccountInspectResponse(resp *http.Response) (res *Blockchai return res, errors.Wrap(defRes, "error") } -func decodeDecodeMessageResponse(resp *http.Response) (res *DecodedMessage, _ error) { +func decodeExecGetMethodWithBodyForBlockchainAccountResponse(resp *http.Response) (res *MethodExecutionResult, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -279,7 +1051,7 @@ func decodeDecodeMessageResponse(resp *http.Response) (res *DecodedMessage, _ er } d := jx.DecodeBytes(buf) - var response DecodedMessage + var response MethodExecutionResult if err := func() error { if err := response.Decode(d); err != nil { return err @@ -296,6 +1068,15 @@ func decodeDecodeMessageResponse(resp *http.Response) (res *DecodedMessage, _ er } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -346,7 +1127,7 @@ func decodeDecodeMessageResponse(resp *http.Response) (res *DecodedMessage, _ er return res, errors.Wrap(defRes, "error") } -func decodeDnsResolveResponse(resp *http.Response) (res *DnsRecord, _ error) { +func decodeGaslessConfigResponse(resp *http.Response) (res *GaslessConfig, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -362,7 +1143,7 @@ func decodeDnsResolveResponse(resp *http.Response) (res *DnsRecord, _ error) { } d := jx.DecodeBytes(buf) - var response DnsRecord + var response GaslessConfig if err := func() error { if err := response.Decode(d); err != nil { return err @@ -379,6 +1160,15 @@ func decodeDnsResolveResponse(resp *http.Response) (res *DnsRecord, _ error) { } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -429,7 +1219,7 @@ func decodeDnsResolveResponse(resp *http.Response) (res *DnsRecord, _ error) { return res, errors.Wrap(defRes, "error") } -func decodeEmulateMessageToAccountEventResponse(resp *http.Response) (res *AccountEvent, _ error) { +func decodeGaslessEstimateResponse(resp *http.Response) (res *SignRawParams, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -445,7 +1235,7 @@ func decodeEmulateMessageToAccountEventResponse(resp *http.Response) (res *Accou } d := jx.DecodeBytes(buf) - var response AccountEvent + var response SignRawParams if err := func() error { if err := response.Decode(d); err != nil { return err @@ -462,6 +1252,15 @@ func decodeEmulateMessageToAccountEventResponse(resp *http.Response) (res *Accou } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -512,7 +1311,7 @@ func decodeEmulateMessageToAccountEventResponse(resp *http.Response) (res *Accou return res, errors.Wrap(defRes, "error") } -func decodeEmulateMessageToEventResponse(resp *http.Response) (res *Event, _ error) { +func decodeGaslessSendResponse(resp *http.Response) (res *GaslessTx, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -528,7 +1327,7 @@ func decodeEmulateMessageToEventResponse(resp *http.Response) (res *Event, _ err } d := jx.DecodeBytes(buf) - var response Event + var response GaslessTx if err := func() error { if err := response.Decode(d); err != nil { return err @@ -595,7 +1394,7 @@ func decodeEmulateMessageToEventResponse(resp *http.Response) (res *Event, _ err return res, errors.Wrap(defRes, "error") } -func decodeEmulateMessageToTraceResponse(resp *http.Response) (res *Trace, _ error) { +func decodeGetAccountResponse(resp *http.Response) (res *Account, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -611,7 +1410,7 @@ func decodeEmulateMessageToTraceResponse(resp *http.Response) (res *Trace, _ err } d := jx.DecodeBytes(buf) - var response Trace + var response Account if err := func() error { if err := response.Decode(d); err != nil { return err @@ -628,6 +1427,15 @@ func decodeEmulateMessageToTraceResponse(resp *http.Response) (res *Trace, _ err } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -678,7 +1486,7 @@ func decodeEmulateMessageToTraceResponse(resp *http.Response) (res *Trace, _ err return res, errors.Wrap(defRes, "error") } -func decodeEmulateMessageToWalletResponse(resp *http.Response) (res *MessageConsequences, _ error) { +func decodeGetAccountDiffResponse(resp *http.Response) (res *GetAccountDiffOK, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -694,7 +1502,7 @@ func decodeEmulateMessageToWalletResponse(resp *http.Response) (res *MessageCons } d := jx.DecodeBytes(buf) - var response MessageConsequences + var response GetAccountDiffOK if err := func() error { if err := response.Decode(d); err != nil { return err @@ -761,7 +1569,7 @@ func decodeEmulateMessageToWalletResponse(resp *http.Response) (res *MessageCons return res, errors.Wrap(defRes, "error") } -func decodeExecGetMethodForBlockchainAccountResponse(resp *http.Response) (res *MethodExecutionResult, _ error) { +func decodeGetAccountDnsExpiringResponse(resp *http.Response) (res *DnsExpiring, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -777,7 +1585,7 @@ func decodeExecGetMethodForBlockchainAccountResponse(resp *http.Response) (res * } d := jx.DecodeBytes(buf) - var response MethodExecutionResult + var response DnsExpiring if err := func() error { if err := response.Decode(d); err != nil { return err @@ -794,6 +1602,15 @@ func decodeExecGetMethodForBlockchainAccountResponse(resp *http.Response) (res * } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -844,7 +1661,7 @@ func decodeExecGetMethodForBlockchainAccountResponse(resp *http.Response) (res * return res, errors.Wrap(defRes, "error") } -func decodeGaslessConfigResponse(resp *http.Response) (res *GaslessConfig, _ error) { +func decodeGetAccountEventResponse(resp *http.Response) (res *AccountEvent, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -860,7 +1677,7 @@ func decodeGaslessConfigResponse(resp *http.Response) (res *GaslessConfig, _ err } d := jx.DecodeBytes(buf) - var response GaslessConfig + var response AccountEvent if err := func() error { if err := response.Decode(d); err != nil { return err @@ -877,6 +1694,15 @@ func decodeGaslessConfigResponse(resp *http.Response) (res *GaslessConfig, _ err } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -927,7 +1753,7 @@ func decodeGaslessConfigResponse(resp *http.Response) (res *GaslessConfig, _ err return res, errors.Wrap(defRes, "error") } -func decodeGaslessEstimateResponse(resp *http.Response) (res *SignRawParams, _ error) { +func decodeGetAccountEventsResponse(resp *http.Response) (res *AccountEvents, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -943,7 +1769,7 @@ func decodeGaslessEstimateResponse(resp *http.Response) (res *SignRawParams, _ e } d := jx.DecodeBytes(buf) - var response SignRawParams + var response AccountEvents if err := func() error { if err := response.Decode(d); err != nil { return err @@ -960,6 +1786,15 @@ func decodeGaslessEstimateResponse(resp *http.Response) (res *SignRawParams, _ e } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -1010,11 +1845,52 @@ func decodeGaslessEstimateResponse(resp *http.Response) (res *SignRawParams, _ e return res, errors.Wrap(defRes, "error") } -func decodeGaslessSendResponse(resp *http.Response) (res *GaslessSendOK, _ error) { +func decodeGetAccountExtraCurrencyHistoryByIDResponse(resp *http.Response) (res *AccountEvents, _ error) { switch resp.StatusCode { case 200: // Code 200. - return &GaslessSendOK{}, nil + 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 AccountEvents + 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 + } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } + return &response, nil + default: + return res, validate.InvalidContentType(ct) + } } // Convenient error response. defRes, err := func() (res *ErrorStatusCode, err error) { @@ -1061,7 +1937,7 @@ func decodeGaslessSendResponse(resp *http.Response) (res *GaslessSendOK, _ error return res, errors.Wrap(defRes, "error") } -func decodeGetAccountResponse(resp *http.Response) (res *Account, _ error) { +func decodeGetAccountInfoByStateInitResponse(resp *http.Response) (res *AccountInfoByStateInit, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -1077,7 +1953,7 @@ func decodeGetAccountResponse(resp *http.Response) (res *Account, _ error) { } d := jx.DecodeBytes(buf) - var response Account + var response AccountInfoByStateInit if err := func() error { if err := response.Decode(d); err != nil { return err @@ -1144,7 +2020,7 @@ func decodeGetAccountResponse(resp *http.Response) (res *Account, _ error) { return res, errors.Wrap(defRes, "error") } -func decodeGetAccountDiffResponse(resp *http.Response) (res *GetAccountDiffOK, _ error) { +func decodeGetAccountJettonBalanceResponse(resp *http.Response) (res *JettonBalance, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -1160,7 +2036,7 @@ func decodeGetAccountDiffResponse(resp *http.Response) (res *GetAccountDiffOK, _ } d := jx.DecodeBytes(buf) - var response GetAccountDiffOK + var response JettonBalance if err := func() error { if err := response.Decode(d); err != nil { return err @@ -1177,6 +2053,15 @@ func decodeGetAccountDiffResponse(resp *http.Response) (res *GetAccountDiffOK, _ } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -1227,7 +2112,7 @@ func decodeGetAccountDiffResponse(resp *http.Response) (res *GetAccountDiffOK, _ return res, errors.Wrap(defRes, "error") } -func decodeGetAccountDnsExpiringResponse(resp *http.Response) (res *DnsExpiring, _ error) { +func decodeGetAccountJettonHistoryByIDResponse(resp *http.Response) (res *AccountEvents, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -1243,7 +2128,7 @@ func decodeGetAccountDnsExpiringResponse(resp *http.Response) (res *DnsExpiring, } d := jx.DecodeBytes(buf) - var response DnsExpiring + var response AccountEvents if err := func() error { if err := response.Decode(d); err != nil { return err @@ -1260,6 +2145,15 @@ func decodeGetAccountDnsExpiringResponse(resp *http.Response) (res *DnsExpiring, } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -1310,7 +2204,7 @@ func decodeGetAccountDnsExpiringResponse(resp *http.Response) (res *DnsExpiring, return res, errors.Wrap(defRes, "error") } -func decodeGetAccountEventResponse(resp *http.Response) (res *AccountEvent, _ error) { +func decodeGetAccountJettonsBalancesResponse(resp *http.Response) (res *JettonsBalances, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -1326,7 +2220,7 @@ func decodeGetAccountEventResponse(resp *http.Response) (res *AccountEvent, _ er } d := jx.DecodeBytes(buf) - var response AccountEvent + var response JettonsBalances if err := func() error { if err := response.Decode(d); err != nil { return err @@ -1343,6 +2237,15 @@ func decodeGetAccountEventResponse(resp *http.Response) (res *AccountEvent, _ er } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -1393,7 +2296,7 @@ func decodeGetAccountEventResponse(resp *http.Response) (res *AccountEvent, _ er return res, errors.Wrap(defRes, "error") } -func decodeGetAccountEventsResponse(resp *http.Response) (res *AccountEvents, _ error) { +func decodeGetAccountJettonsHistoryResponse(resp *http.Response) (res *JettonOperations, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -1409,7 +2312,7 @@ func decodeGetAccountEventsResponse(resp *http.Response) (res *AccountEvents, _ } d := jx.DecodeBytes(buf) - var response AccountEvents + var response JettonOperations if err := func() error { if err := response.Decode(d); err != nil { return err @@ -1426,6 +2329,15 @@ func decodeGetAccountEventsResponse(resp *http.Response) (res *AccountEvents, _ } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -1476,7 +2388,7 @@ func decodeGetAccountEventsResponse(resp *http.Response) (res *AccountEvents, _ return res, errors.Wrap(defRes, "error") } -func decodeGetAccountInfoByStateInitResponse(resp *http.Response) (res *AccountInfoByStateInit, _ error) { +func decodeGetAccountMultisigsResponse(resp *http.Response) (res *Multisigs, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -1492,7 +2404,7 @@ func decodeGetAccountInfoByStateInitResponse(resp *http.Response) (res *AccountI } d := jx.DecodeBytes(buf) - var response AccountInfoByStateInit + var response Multisigs if err := func() error { if err := response.Decode(d); err != nil { return err @@ -1509,6 +2421,15 @@ func decodeGetAccountInfoByStateInitResponse(resp *http.Response) (res *AccountI } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -1559,7 +2480,7 @@ func decodeGetAccountInfoByStateInitResponse(resp *http.Response) (res *AccountI return res, errors.Wrap(defRes, "error") } -func decodeGetAccountInscriptionsResponse(resp *http.Response) (res *InscriptionBalances, _ error) { +func decodeGetAccountNftHistoryResponse(resp *http.Response) (res *NftOperations, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -1575,7 +2496,7 @@ func decodeGetAccountInscriptionsResponse(resp *http.Response) (res *Inscription } d := jx.DecodeBytes(buf) - var response InscriptionBalances + var response NftOperations if err := func() error { if err := response.Decode(d); err != nil { return err @@ -1592,6 +2513,15 @@ func decodeGetAccountInscriptionsResponse(resp *http.Response) (res *Inscription } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -1642,7 +2572,7 @@ func decodeGetAccountInscriptionsResponse(resp *http.Response) (res *Inscription return res, errors.Wrap(defRes, "error") } -func decodeGetAccountInscriptionsHistoryResponse(resp *http.Response) (res *AccountEvents, _ error) { +func decodeGetAccountNftItemsResponse(resp *http.Response) (res *NftItems, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -1658,7 +2588,7 @@ func decodeGetAccountInscriptionsHistoryResponse(resp *http.Response) (res *Acco } d := jx.DecodeBytes(buf) - var response AccountEvents + var response NftItems if err := func() error { if err := response.Decode(d); err != nil { return err @@ -1675,6 +2605,15 @@ func decodeGetAccountInscriptionsHistoryResponse(resp *http.Response) (res *Acco } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -1725,7 +2664,7 @@ func decodeGetAccountInscriptionsHistoryResponse(resp *http.Response) (res *Acco return res, errors.Wrap(defRes, "error") } -func decodeGetAccountInscriptionsHistoryByTickerResponse(resp *http.Response) (res *AccountEvents, _ error) { +func decodeGetAccountNominatorsPoolsResponse(resp *http.Response) (res *AccountStaking, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -1741,7 +2680,7 @@ func decodeGetAccountInscriptionsHistoryByTickerResponse(resp *http.Response) (r } d := jx.DecodeBytes(buf) - var response AccountEvents + var response AccountStaking if err := func() error { if err := response.Decode(d); err != nil { return err @@ -1758,6 +2697,15 @@ func decodeGetAccountInscriptionsHistoryByTickerResponse(resp *http.Response) (r } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -1808,7 +2756,7 @@ func decodeGetAccountInscriptionsHistoryByTickerResponse(resp *http.Response) (r return res, errors.Wrap(defRes, "error") } -func decodeGetAccountJettonBalanceResponse(resp *http.Response) (res *JettonBalance, _ error) { +func decodeGetAccountPublicKeyResponse(resp *http.Response) (res *GetAccountPublicKeyOK, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -1824,7 +2772,7 @@ func decodeGetAccountJettonBalanceResponse(resp *http.Response) (res *JettonBala } d := jx.DecodeBytes(buf) - var response JettonBalance + var response GetAccountPublicKeyOK if err := func() error { if err := response.Decode(d); err != nil { return err @@ -1891,7 +2839,7 @@ func decodeGetAccountJettonBalanceResponse(resp *http.Response) (res *JettonBala return res, errors.Wrap(defRes, "error") } -func decodeGetAccountJettonHistoryByIDResponse(resp *http.Response) (res *AccountEvents, _ error) { +func decodeGetAccountSeqnoResponse(resp *http.Response) (res *Seqno, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -1907,7 +2855,7 @@ func decodeGetAccountJettonHistoryByIDResponse(resp *http.Response) (res *Accoun } d := jx.DecodeBytes(buf) - var response AccountEvents + var response Seqno if err := func() error { if err := response.Decode(d); err != nil { return err @@ -1974,7 +2922,7 @@ func decodeGetAccountJettonHistoryByIDResponse(resp *http.Response) (res *Accoun return res, errors.Wrap(defRes, "error") } -func decodeGetAccountJettonsBalancesResponse(resp *http.Response) (res *JettonsBalances, _ error) { +func decodeGetAccountSubscriptionsResponse(resp *http.Response) (res *Subscriptions, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -1990,7 +2938,7 @@ func decodeGetAccountJettonsBalancesResponse(resp *http.Response) (res *JettonsB } d := jx.DecodeBytes(buf) - var response JettonsBalances + var response Subscriptions if err := func() error { if err := response.Decode(d); err != nil { return err @@ -2007,6 +2955,15 @@ func decodeGetAccountJettonsBalancesResponse(resp *http.Response) (res *JettonsB } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -2057,7 +3014,7 @@ func decodeGetAccountJettonsBalancesResponse(resp *http.Response) (res *JettonsB return res, errors.Wrap(defRes, "error") } -func decodeGetAccountJettonsHistoryResponse(resp *http.Response) (res *AccountEvents, _ error) { +func decodeGetAccountTracesResponse(resp *http.Response) (res *TraceIDs, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -2073,7 +3030,7 @@ func decodeGetAccountJettonsHistoryResponse(resp *http.Response) (res *AccountEv } d := jx.DecodeBytes(buf) - var response AccountEvents + var response TraceIDs if err := func() error { if err := response.Decode(d); err != nil { return err @@ -2090,6 +3047,15 @@ func decodeGetAccountJettonsHistoryResponse(resp *http.Response) (res *AccountEv } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -2140,7 +3106,7 @@ func decodeGetAccountJettonsHistoryResponse(resp *http.Response) (res *AccountEv return res, errors.Wrap(defRes, "error") } -func decodeGetAccountMultisigsResponse(resp *http.Response) (res *Multisigs, _ error) { +func decodeGetAccountsResponse(resp *http.Response) (res *Accounts, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -2156,7 +3122,7 @@ func decodeGetAccountMultisigsResponse(resp *http.Response) (res *Multisigs, _ e } d := jx.DecodeBytes(buf) - var response Multisigs + var response Accounts if err := func() error { if err := response.Decode(d); err != nil { return err @@ -2173,6 +3139,15 @@ func decodeGetAccountMultisigsResponse(resp *http.Response) (res *Multisigs, _ e } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -2223,7 +3198,7 @@ func decodeGetAccountMultisigsResponse(resp *http.Response) (res *Multisigs, _ e return res, errors.Wrap(defRes, "error") } -func decodeGetAccountNftHistoryResponse(resp *http.Response) (res *AccountEvents, _ error) { +func decodeGetAllAuctionsResponse(resp *http.Response) (res *Auctions, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -2239,7 +3214,7 @@ func decodeGetAccountNftHistoryResponse(resp *http.Response) (res *AccountEvents } d := jx.DecodeBytes(buf) - var response AccountEvents + var response Auctions if err := func() error { if err := response.Decode(d); err != nil { return err @@ -2256,6 +3231,15 @@ func decodeGetAccountNftHistoryResponse(resp *http.Response) (res *AccountEvents } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -2306,7 +3290,7 @@ func decodeGetAccountNftHistoryResponse(resp *http.Response) (res *AccountEvents return res, errors.Wrap(defRes, "error") } -func decodeGetAccountNftItemsResponse(resp *http.Response) (res *NftItems, _ error) { +func decodeGetAllRawShardsInfoResponse(resp *http.Response) (res *GetAllRawShardsInfoOK, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -2322,7 +3306,7 @@ func decodeGetAccountNftItemsResponse(resp *http.Response) (res *NftItems, _ err } d := jx.DecodeBytes(buf) - var response NftItems + var response GetAllRawShardsInfoOK if err := func() error { if err := response.Decode(d); err != nil { return err @@ -2389,7 +3373,7 @@ func decodeGetAccountNftItemsResponse(resp *http.Response) (res *NftItems, _ err return res, errors.Wrap(defRes, "error") } -func decodeGetAccountNominatorsPoolsResponse(resp *http.Response) (res *AccountStaking, _ error) { +func decodeGetBlockchainAccountTransactionsResponse(resp *http.Response) (res *Transactions, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -2405,7 +3389,7 @@ func decodeGetAccountNominatorsPoolsResponse(resp *http.Response) (res *AccountS } d := jx.DecodeBytes(buf) - var response AccountStaking + var response Transactions if err := func() error { if err := response.Decode(d); err != nil { return err @@ -2422,6 +3406,15 @@ func decodeGetAccountNominatorsPoolsResponse(resp *http.Response) (res *AccountS } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -2472,7 +3465,7 @@ func decodeGetAccountNominatorsPoolsResponse(resp *http.Response) (res *AccountS return res, errors.Wrap(defRes, "error") } -func decodeGetAccountPublicKeyResponse(resp *http.Response) (res *GetAccountPublicKeyOK, _ error) { +func decodeGetBlockchainBlockResponse(resp *http.Response) (res *BlockchainBlock, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -2488,7 +3481,7 @@ func decodeGetAccountPublicKeyResponse(resp *http.Response) (res *GetAccountPubl } d := jx.DecodeBytes(buf) - var response GetAccountPublicKeyOK + var response BlockchainBlock if err := func() error { if err := response.Decode(d); err != nil { return err @@ -2505,6 +3498,15 @@ func decodeGetAccountPublicKeyResponse(resp *http.Response) (res *GetAccountPubl } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -2555,7 +3557,7 @@ func decodeGetAccountPublicKeyResponse(resp *http.Response) (res *GetAccountPubl return res, errors.Wrap(defRes, "error") } -func decodeGetAccountSeqnoResponse(resp *http.Response) (res *Seqno, _ error) { +func decodeGetBlockchainBlockTransactionsResponse(resp *http.Response) (res *Transactions, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -2571,7 +3573,7 @@ func decodeGetAccountSeqnoResponse(resp *http.Response) (res *Seqno, _ error) { } d := jx.DecodeBytes(buf) - var response Seqno + var response Transactions if err := func() error { if err := response.Decode(d); err != nil { return err @@ -2588,6 +3590,15 @@ func decodeGetAccountSeqnoResponse(resp *http.Response) (res *Seqno, _ error) { } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -2638,7 +3649,7 @@ func decodeGetAccountSeqnoResponse(resp *http.Response) (res *Seqno, _ error) { return res, errors.Wrap(defRes, "error") } -func decodeGetAccountSubscriptionsResponse(resp *http.Response) (res *Subscriptions, _ error) { +func decodeGetBlockchainConfigResponse(resp *http.Response) (res *BlockchainConfig, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -2654,7 +3665,7 @@ func decodeGetAccountSubscriptionsResponse(resp *http.Response) (res *Subscripti } d := jx.DecodeBytes(buf) - var response Subscriptions + var response BlockchainConfig if err := func() error { if err := response.Decode(d); err != nil { return err @@ -2671,6 +3682,15 @@ func decodeGetAccountSubscriptionsResponse(resp *http.Response) (res *Subscripti } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -2721,7 +3741,7 @@ func decodeGetAccountSubscriptionsResponse(resp *http.Response) (res *Subscripti return res, errors.Wrap(defRes, "error") } -func decodeGetAccountTracesResponse(resp *http.Response) (res *TraceIDs, _ error) { +func decodeGetBlockchainConfigFromBlockResponse(resp *http.Response) (res *BlockchainConfig, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -2737,7 +3757,7 @@ func decodeGetAccountTracesResponse(resp *http.Response) (res *TraceIDs, _ error } d := jx.DecodeBytes(buf) - var response TraceIDs + var response BlockchainConfig if err := func() error { if err := response.Decode(d); err != nil { return err @@ -2754,6 +3774,15 @@ func decodeGetAccountTracesResponse(resp *http.Response) (res *TraceIDs, _ error } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -2804,7 +3833,7 @@ func decodeGetAccountTracesResponse(resp *http.Response) (res *TraceIDs, _ error return res, errors.Wrap(defRes, "error") } -func decodeGetAccountsResponse(resp *http.Response) (res *Accounts, _ error) { +func decodeGetBlockchainMasterchainBlocksResponse(resp *http.Response) (res *BlockchainBlocks, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -2820,7 +3849,7 @@ func decodeGetAccountsResponse(resp *http.Response) (res *Accounts, _ error) { } d := jx.DecodeBytes(buf) - var response Accounts + var response BlockchainBlocks if err := func() error { if err := response.Decode(d); err != nil { return err @@ -2837,6 +3866,15 @@ func decodeGetAccountsResponse(resp *http.Response) (res *Accounts, _ error) { } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -2887,7 +3925,7 @@ func decodeGetAccountsResponse(resp *http.Response) (res *Accounts, _ error) { return res, errors.Wrap(defRes, "error") } -func decodeGetAllAuctionsResponse(resp *http.Response) (res *Auctions, _ error) { +func decodeGetBlockchainMasterchainHeadResponse(resp *http.Response) (res *BlockchainBlock, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -2903,7 +3941,7 @@ func decodeGetAllAuctionsResponse(resp *http.Response) (res *Auctions, _ error) } d := jx.DecodeBytes(buf) - var response Auctions + var response BlockchainBlock if err := func() error { if err := response.Decode(d); err != nil { return err @@ -2920,6 +3958,15 @@ func decodeGetAllAuctionsResponse(resp *http.Response) (res *Auctions, _ error) } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -2970,7 +4017,7 @@ func decodeGetAllAuctionsResponse(resp *http.Response) (res *Auctions, _ error) return res, errors.Wrap(defRes, "error") } -func decodeGetAllRawShardsInfoResponse(resp *http.Response) (res *GetAllRawShardsInfoOK, _ error) { +func decodeGetBlockchainMasterchainShardsResponse(resp *http.Response) (res *BlockchainBlockShards, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -2986,7 +4033,7 @@ func decodeGetAllRawShardsInfoResponse(resp *http.Response) (res *GetAllRawShard } d := jx.DecodeBytes(buf) - var response GetAllRawShardsInfoOK + var response BlockchainBlockShards if err := func() error { if err := response.Decode(d); err != nil { return err @@ -3003,6 +4050,15 @@ func decodeGetAllRawShardsInfoResponse(resp *http.Response) (res *GetAllRawShard } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -3053,7 +4109,7 @@ func decodeGetAllRawShardsInfoResponse(resp *http.Response) (res *GetAllRawShard return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainAccountTransactionsResponse(resp *http.Response) (res *Transactions, _ error) { +func decodeGetBlockchainMasterchainTransactionsResponse(resp *http.Response) (res *Transactions, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -3086,6 +4142,15 @@ func decodeGetBlockchainAccountTransactionsResponse(resp *http.Response) (res *T } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -3136,7 +4201,7 @@ func decodeGetBlockchainAccountTransactionsResponse(resp *http.Response) (res *T return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainBlockResponse(resp *http.Response) (res *BlockchainBlock, _ error) { +func decodeGetBlockchainRawAccountResponse(resp *http.Response) (res *BlockchainRawAccount, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -3152,7 +4217,7 @@ func decodeGetBlockchainBlockResponse(resp *http.Response) (res *BlockchainBlock } d := jx.DecodeBytes(buf) - var response BlockchainBlock + var response BlockchainRawAccount if err := func() error { if err := response.Decode(d); err != nil { return err @@ -3169,6 +4234,15 @@ func decodeGetBlockchainBlockResponse(resp *http.Response) (res *BlockchainBlock } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -3219,7 +4293,7 @@ func decodeGetBlockchainBlockResponse(resp *http.Response) (res *BlockchainBlock return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainBlockTransactionsResponse(resp *http.Response) (res *Transactions, _ error) { +func decodeGetBlockchainTransactionResponse(resp *http.Response) (res *Transaction, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -3235,7 +4309,7 @@ func decodeGetBlockchainBlockTransactionsResponse(resp *http.Response) (res *Tra } d := jx.DecodeBytes(buf) - var response Transactions + var response Transaction if err := func() error { if err := response.Decode(d); err != nil { return err @@ -3252,6 +4326,15 @@ func decodeGetBlockchainBlockTransactionsResponse(resp *http.Response) (res *Tra } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -3302,7 +4385,7 @@ func decodeGetBlockchainBlockTransactionsResponse(resp *http.Response) (res *Tra return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainConfigResponse(resp *http.Response) (res *BlockchainConfig, _ error) { +func decodeGetBlockchainTransactionByMessageHashResponse(resp *http.Response) (res *Transaction, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -3318,7 +4401,7 @@ func decodeGetBlockchainConfigResponse(resp *http.Response) (res *BlockchainConf } d := jx.DecodeBytes(buf) - var response BlockchainConfig + var response Transaction if err := func() error { if err := response.Decode(d); err != nil { return err @@ -3335,6 +4418,15 @@ func decodeGetBlockchainConfigResponse(resp *http.Response) (res *BlockchainConf } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -3385,7 +4477,7 @@ func decodeGetBlockchainConfigResponse(resp *http.Response) (res *BlockchainConf return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainConfigFromBlockResponse(resp *http.Response) (res *BlockchainConfig, _ error) { +func decodeGetBlockchainValidatorsResponse(resp *http.Response) (res *Validators, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -3401,7 +4493,7 @@ func decodeGetBlockchainConfigFromBlockResponse(resp *http.Response) (res *Block } d := jx.DecodeBytes(buf) - var response BlockchainConfig + var response Validators if err := func() error { if err := response.Decode(d); err != nil { return err @@ -3418,6 +4510,15 @@ func decodeGetBlockchainConfigFromBlockResponse(resp *http.Response) (res *Block } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -3468,7 +4569,7 @@ func decodeGetBlockchainConfigFromBlockResponse(resp *http.Response) (res *Block return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainMasterchainBlocksResponse(resp *http.Response) (res *BlockchainBlocks, _ error) { +func decodeGetChartRatesResponse(resp *http.Response) (res *GetChartRatesOK, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -3484,7 +4585,7 @@ func decodeGetBlockchainMasterchainBlocksResponse(resp *http.Response) (res *Blo } d := jx.DecodeBytes(buf) - var response BlockchainBlocks + var response GetChartRatesOK if err := func() error { if err := response.Decode(d); err != nil { return err @@ -3501,6 +4602,15 @@ func decodeGetBlockchainMasterchainBlocksResponse(resp *http.Response) (res *Blo } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -3551,7 +4661,7 @@ func decodeGetBlockchainMasterchainBlocksResponse(resp *http.Response) (res *Blo return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainMasterchainHeadResponse(resp *http.Response) (res *BlockchainBlock, _ error) { +func decodeGetDnsInfoResponse(resp *http.Response) (res *DomainInfo, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -3567,7 +4677,7 @@ func decodeGetBlockchainMasterchainHeadResponse(resp *http.Response) (res *Block } d := jx.DecodeBytes(buf) - var response BlockchainBlock + var response DomainInfo if err := func() error { if err := response.Decode(d); err != nil { return err @@ -3584,6 +4694,15 @@ func decodeGetBlockchainMasterchainHeadResponse(resp *http.Response) (res *Block } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -3634,7 +4753,7 @@ func decodeGetBlockchainMasterchainHeadResponse(resp *http.Response) (res *Block return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainMasterchainShardsResponse(resp *http.Response) (res *BlockchainBlockShards, _ error) { +func decodeGetDomainBidsResponse(resp *http.Response) (res *DomainBids, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -3650,7 +4769,7 @@ func decodeGetBlockchainMasterchainShardsResponse(resp *http.Response) (res *Blo } d := jx.DecodeBytes(buf) - var response BlockchainBlockShards + var response DomainBids if err := func() error { if err := response.Decode(d); err != nil { return err @@ -3667,6 +4786,15 @@ func decodeGetBlockchainMasterchainShardsResponse(resp *http.Response) (res *Blo } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -3717,7 +4845,7 @@ func decodeGetBlockchainMasterchainShardsResponse(resp *http.Response) (res *Blo return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainMasterchainTransactionsResponse(resp *http.Response) (res *Transactions, _ error) { +func decodeGetEventResponse(resp *http.Response) (res *Event, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -3733,7 +4861,7 @@ func decodeGetBlockchainMasterchainTransactionsResponse(resp *http.Response) (re } d := jx.DecodeBytes(buf) - var response Transactions + var response Event if err := func() error { if err := response.Decode(d); err != nil { return err @@ -3750,6 +4878,15 @@ func decodeGetBlockchainMasterchainTransactionsResponse(resp *http.Response) (re } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -3800,7 +4937,7 @@ func decodeGetBlockchainMasterchainTransactionsResponse(resp *http.Response) (re return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainRawAccountResponse(resp *http.Response) (res *BlockchainRawAccount, _ error) { +func decodeGetExtraCurrencyInfoResponse(resp *http.Response) (res *EcPreview, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -3816,7 +4953,7 @@ func decodeGetBlockchainRawAccountResponse(resp *http.Response) (res *Blockchain } d := jx.DecodeBytes(buf) - var response BlockchainRawAccount + var response EcPreview if err := func() error { if err := response.Decode(d); err != nil { return err @@ -3883,7 +5020,7 @@ func decodeGetBlockchainRawAccountResponse(resp *http.Response) (res *Blockchain return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainTransactionResponse(resp *http.Response) (res *Transaction, _ error) { +func decodeGetItemsFromCollectionResponse(resp *http.Response) (res *NftItems, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -3899,7 +5036,7 @@ func decodeGetBlockchainTransactionResponse(resp *http.Response) (res *Transacti } d := jx.DecodeBytes(buf) - var response Transaction + var response NftItems if err := func() error { if err := response.Decode(d); err != nil { return err @@ -3916,6 +5053,15 @@ func decodeGetBlockchainTransactionResponse(resp *http.Response) (res *Transacti } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -3966,7 +5112,7 @@ func decodeGetBlockchainTransactionResponse(resp *http.Response) (res *Transacti return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainTransactionByMessageHashResponse(resp *http.Response) (res *Transaction, _ error) { +func decodeGetJettonAccountHistoryByIDResponse(resp *http.Response) (res *JettonOperations, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -3982,7 +5128,7 @@ func decodeGetBlockchainTransactionByMessageHashResponse(resp *http.Response) (r } d := jx.DecodeBytes(buf) - var response Transaction + var response JettonOperations if err := func() error { if err := response.Decode(d); err != nil { return err @@ -3999,6 +5145,15 @@ func decodeGetBlockchainTransactionByMessageHashResponse(resp *http.Response) (r } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -4049,7 +5204,7 @@ func decodeGetBlockchainTransactionByMessageHashResponse(resp *http.Response) (r return res, errors.Wrap(defRes, "error") } -func decodeGetBlockchainValidatorsResponse(resp *http.Response) (res *Validators, _ error) { +func decodeGetJettonHoldersResponse(resp *http.Response) (res *JettonHolders, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -4065,7 +5220,7 @@ func decodeGetBlockchainValidatorsResponse(resp *http.Response) (res *Validators } d := jx.DecodeBytes(buf) - var response Validators + var response JettonHolders if err := func() error { if err := response.Decode(d); err != nil { return err @@ -4082,6 +5237,15 @@ func decodeGetBlockchainValidatorsResponse(resp *http.Response) (res *Validators } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -4132,7 +5296,7 @@ func decodeGetBlockchainValidatorsResponse(resp *http.Response) (res *Validators return res, errors.Wrap(defRes, "error") } -func decodeGetChartRatesResponse(resp *http.Response) (res *GetChartRatesOK, _ error) { +func decodeGetJettonInfoResponse(resp *http.Response) (res *JettonInfo, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -4148,7 +5312,7 @@ func decodeGetChartRatesResponse(resp *http.Response) (res *GetChartRatesOK, _ e } d := jx.DecodeBytes(buf) - var response GetChartRatesOK + var response JettonInfo if err := func() error { if err := response.Decode(d); err != nil { return err @@ -4165,6 +5329,15 @@ func decodeGetChartRatesResponse(resp *http.Response) (res *GetChartRatesOK, _ e } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -4215,7 +5388,7 @@ func decodeGetChartRatesResponse(resp *http.Response) (res *GetChartRatesOK, _ e return res, errors.Wrap(defRes, "error") } -func decodeGetDnsInfoResponse(resp *http.Response) (res *DomainInfo, _ error) { +func decodeGetJettonInfosByAddressesResponse(resp *http.Response) (res *Jettons, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -4231,7 +5404,7 @@ func decodeGetDnsInfoResponse(resp *http.Response) (res *DomainInfo, _ error) { } d := jx.DecodeBytes(buf) - var response DomainInfo + var response Jettons if err := func() error { if err := response.Decode(d); err != nil { return err @@ -4248,6 +5421,15 @@ func decodeGetDnsInfoResponse(resp *http.Response) (res *DomainInfo, _ error) { } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -4298,7 +5480,7 @@ func decodeGetDnsInfoResponse(resp *http.Response) (res *DomainInfo, _ error) { return res, errors.Wrap(defRes, "error") } -func decodeGetDomainBidsResponse(resp *http.Response) (res *DomainBids, _ error) { +func decodeGetJettonTransferPayloadResponse(resp *http.Response) (res *JettonTransferPayload, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -4314,7 +5496,7 @@ func decodeGetDomainBidsResponse(resp *http.Response) (res *DomainBids, _ error) } d := jx.DecodeBytes(buf) - var response DomainBids + var response JettonTransferPayload if err := func() error { if err := response.Decode(d); err != nil { return err @@ -4381,7 +5563,7 @@ func decodeGetDomainBidsResponse(resp *http.Response) (res *DomainBids, _ error) return res, errors.Wrap(defRes, "error") } -func decodeGetEventResponse(resp *http.Response) (res *Event, _ error) { +func decodeGetJettonsResponse(resp *http.Response) (res *Jettons, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -4397,7 +5579,7 @@ func decodeGetEventResponse(resp *http.Response) (res *Event, _ error) { } d := jx.DecodeBytes(buf) - var response Event + var response Jettons if err := func() error { if err := response.Decode(d); err != nil { return err @@ -4414,6 +5596,15 @@ func decodeGetEventResponse(resp *http.Response) (res *Event, _ error) { } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -4464,7 +5655,7 @@ func decodeGetEventResponse(resp *http.Response) (res *Event, _ error) { return res, errors.Wrap(defRes, "error") } -func decodeGetInscriptionOpTemplateResponse(resp *http.Response) (res *GetInscriptionOpTemplateOK, _ error) { +func decodeGetJettonsEventsResponse(resp *http.Response) (res *Event, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -4480,7 +5671,7 @@ func decodeGetInscriptionOpTemplateResponse(resp *http.Response) (res *GetInscri } d := jx.DecodeBytes(buf) - var response GetInscriptionOpTemplateOK + var response Event if err := func() error { if err := response.Decode(d); err != nil { return err @@ -4497,6 +5688,15 @@ func decodeGetInscriptionOpTemplateResponse(resp *http.Response) (res *GetInscri } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -4547,7 +5747,7 @@ func decodeGetInscriptionOpTemplateResponse(resp *http.Response) (res *GetInscri return res, errors.Wrap(defRes, "error") } -func decodeGetItemsFromCollectionResponse(resp *http.Response) (res *NftItems, _ error) { +func decodeGetLibraryByHashResponse(resp *http.Response) (res *BlockchainLibrary, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -4563,7 +5763,7 @@ func decodeGetItemsFromCollectionResponse(resp *http.Response) (res *NftItems, _ } d := jx.DecodeBytes(buf) - var response NftItems + var response BlockchainLibrary if err := func() error { if err := response.Decode(d); err != nil { return err @@ -4630,7 +5830,7 @@ func decodeGetItemsFromCollectionResponse(resp *http.Response) (res *NftItems, _ return res, errors.Wrap(defRes, "error") } -func decodeGetJettonHoldersResponse(resp *http.Response) (res *JettonHolders, _ error) { +func decodeGetMarketsRatesResponse(resp *http.Response) (res *GetMarketsRatesOK, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -4646,7 +5846,7 @@ func decodeGetJettonHoldersResponse(resp *http.Response) (res *JettonHolders, _ } d := jx.DecodeBytes(buf) - var response JettonHolders + var response GetMarketsRatesOK if err := func() error { if err := response.Decode(d); err != nil { return err @@ -4663,6 +5863,15 @@ func decodeGetJettonHoldersResponse(resp *http.Response) (res *JettonHolders, _ } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -4713,7 +5922,7 @@ func decodeGetJettonHoldersResponse(resp *http.Response) (res *JettonHolders, _ return res, errors.Wrap(defRes, "error") } -func decodeGetJettonInfoResponse(resp *http.Response) (res *JettonInfo, _ error) { +func decodeGetMultisigAccountResponse(resp *http.Response) (res *Multisig, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -4729,7 +5938,7 @@ func decodeGetJettonInfoResponse(resp *http.Response) (res *JettonInfo, _ error) } d := jx.DecodeBytes(buf) - var response JettonInfo + var response Multisig if err := func() error { if err := response.Decode(d); err != nil { return err @@ -4746,6 +5955,15 @@ func decodeGetJettonInfoResponse(resp *http.Response) (res *JettonInfo, _ error) } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -4796,7 +6014,7 @@ func decodeGetJettonInfoResponse(resp *http.Response) (res *JettonInfo, _ error) return res, errors.Wrap(defRes, "error") } -func decodeGetJettonTransferPayloadResponse(resp *http.Response) (res *JettonTransferPayload, _ error) { +func decodeGetMultisigOrderResponse(resp *http.Response) (res *MultisigOrder, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -4812,7 +6030,7 @@ func decodeGetJettonTransferPayloadResponse(resp *http.Response) (res *JettonTra } d := jx.DecodeBytes(buf) - var response JettonTransferPayload + var response MultisigOrder if err := func() error { if err := response.Decode(d); err != nil { return err @@ -4829,6 +6047,15 @@ func decodeGetJettonTransferPayloadResponse(resp *http.Response) (res *JettonTra } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -4879,7 +6106,7 @@ func decodeGetJettonTransferPayloadResponse(resp *http.Response) (res *JettonTra return res, errors.Wrap(defRes, "error") } -func decodeGetJettonsResponse(resp *http.Response) (res *Jettons, _ error) { +func decodeGetNftCollectionResponse(resp *http.Response) (res *NftCollection, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -4895,7 +6122,7 @@ func decodeGetJettonsResponse(resp *http.Response) (res *Jettons, _ error) { } d := jx.DecodeBytes(buf) - var response Jettons + var response NftCollection if err := func() error { if err := response.Decode(d); err != nil { return err @@ -4912,6 +6139,15 @@ func decodeGetJettonsResponse(resp *http.Response) (res *Jettons, _ error) { } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -4962,7 +6198,7 @@ func decodeGetJettonsResponse(resp *http.Response) (res *Jettons, _ error) { return res, errors.Wrap(defRes, "error") } -func decodeGetJettonsEventsResponse(resp *http.Response) (res *Event, _ error) { +func decodeGetNftCollectionItemsByAddressesResponse(resp *http.Response) (res *NftCollections, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -4978,7 +6214,7 @@ func decodeGetJettonsEventsResponse(resp *http.Response) (res *Event, _ error) { } d := jx.DecodeBytes(buf) - var response Event + var response NftCollections if err := func() error { if err := response.Decode(d); err != nil { return err @@ -4995,6 +6231,15 @@ func decodeGetJettonsEventsResponse(resp *http.Response) (res *Event, _ error) { } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -5045,7 +6290,7 @@ func decodeGetJettonsEventsResponse(resp *http.Response) (res *Event, _ error) { return res, errors.Wrap(defRes, "error") } -func decodeGetMarketsRatesResponse(resp *http.Response) (res *GetMarketsRatesOK, _ error) { +func decodeGetNftCollectionsResponse(resp *http.Response) (res *NftCollections, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -5061,7 +6306,7 @@ func decodeGetMarketsRatesResponse(resp *http.Response) (res *GetMarketsRatesOK, } d := jx.DecodeBytes(buf) - var response GetMarketsRatesOK + var response NftCollections if err := func() error { if err := response.Decode(d); err != nil { return err @@ -5078,6 +6323,15 @@ func decodeGetMarketsRatesResponse(resp *http.Response) (res *GetMarketsRatesOK, } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -5128,7 +6382,7 @@ func decodeGetMarketsRatesResponse(resp *http.Response) (res *GetMarketsRatesOK, return res, errors.Wrap(defRes, "error") } -func decodeGetMultisigAccountResponse(resp *http.Response) (res *Multisig, _ error) { +func decodeGetNftHistoryByIDResponse(resp *http.Response) (res *AccountEvents, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -5144,7 +6398,7 @@ func decodeGetMultisigAccountResponse(resp *http.Response) (res *Multisig, _ err } d := jx.DecodeBytes(buf) - var response Multisig + var response AccountEvents if err := func() error { if err := response.Decode(d); err != nil { return err @@ -5161,6 +6415,15 @@ func decodeGetMultisigAccountResponse(resp *http.Response) (res *Multisig, _ err } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -5211,7 +6474,7 @@ func decodeGetMultisigAccountResponse(resp *http.Response) (res *Multisig, _ err return res, errors.Wrap(defRes, "error") } -func decodeGetNftCollectionResponse(resp *http.Response) (res *NftCollection, _ error) { +func decodeGetNftItemByAddressResponse(resp *http.Response) (res *NftItem, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -5227,7 +6490,7 @@ func decodeGetNftCollectionResponse(resp *http.Response) (res *NftCollection, _ } d := jx.DecodeBytes(buf) - var response NftCollection + var response NftItem if err := func() error { if err := response.Decode(d); err != nil { return err @@ -5244,6 +6507,15 @@ func decodeGetNftCollectionResponse(resp *http.Response) (res *NftCollection, _ } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -5294,7 +6566,7 @@ func decodeGetNftCollectionResponse(resp *http.Response) (res *NftCollection, _ return res, errors.Wrap(defRes, "error") } -func decodeGetNftCollectionsResponse(resp *http.Response) (res *NftCollections, _ error) { +func decodeGetNftItemsByAddressesResponse(resp *http.Response) (res *NftItems, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -5310,7 +6582,7 @@ func decodeGetNftCollectionsResponse(resp *http.Response) (res *NftCollections, } d := jx.DecodeBytes(buf) - var response NftCollections + var response NftItems if err := func() error { if err := response.Decode(d); err != nil { return err @@ -5327,6 +6599,15 @@ func decodeGetNftCollectionsResponse(resp *http.Response) (res *NftCollections, } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -5377,7 +6658,7 @@ func decodeGetNftCollectionsResponse(resp *http.Response) (res *NftCollections, return res, errors.Wrap(defRes, "error") } -func decodeGetNftHistoryByIDResponse(resp *http.Response) (res *AccountEvents, _ error) { +func decodeGetOpenapiJsonResponse(resp *http.Response) (res jx.Raw, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -5393,9 +6674,11 @@ func decodeGetNftHistoryByIDResponse(resp *http.Response) (res *AccountEvents, _ } d := jx.DecodeBytes(buf) - var response AccountEvents + var response jx.Raw if err := func() error { - if err := response.Decode(d); err != nil { + v, err := d.RawAppend(nil) + response = jx.Raw(v) + if err != nil { return err } if err := d.Skip(); err != io.EOF { @@ -5410,7 +6693,7 @@ func decodeGetNftHistoryByIDResponse(resp *http.Response) (res *AccountEvents, _ } return res, err } - return &response, nil + return response, nil default: return res, validate.InvalidContentType(ct) } @@ -5460,7 +6743,7 @@ func decodeGetNftHistoryByIDResponse(resp *http.Response) (res *AccountEvents, _ return res, errors.Wrap(defRes, "error") } -func decodeGetNftItemByAddressResponse(resp *http.Response) (res *NftItem, _ error) { +func decodeGetOpenapiYmlResponse(resp *http.Response) (res GetOpenapiYmlOK, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -5469,31 +6752,15 @@ func decodeGetNftItemByAddressResponse(resp *http.Response) (res *NftItem, _ err return res, errors.Wrap(err, "parse media type") } switch { - case ct == "application/json": - buf, err := io.ReadAll(resp.Body) + case ct == "application/yaml": + reader := resp.Body + b, err := io.ReadAll(reader) if err != nil { return res, err } - d := jx.DecodeBytes(buf) - var response NftItem - 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 + response := GetOpenapiYmlOK{Data: bytes.NewReader(b)} + return response, nil default: return res, validate.InvalidContentType(ct) } @@ -5543,7 +6810,7 @@ func decodeGetNftItemByAddressResponse(resp *http.Response) (res *NftItem, _ err return res, errors.Wrap(defRes, "error") } -func decodeGetNftItemsByAddressesResponse(resp *http.Response) (res *NftItems, _ error) { +func decodeGetOutMsgQueueSizesResponse(resp *http.Response) (res *GetOutMsgQueueSizesOK, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -5559,7 +6826,7 @@ func decodeGetNftItemsByAddressesResponse(resp *http.Response) (res *NftItems, _ } d := jx.DecodeBytes(buf) - var response NftItems + var response GetOutMsgQueueSizesOK if err := func() error { if err := response.Decode(d); err != nil { return err @@ -5576,6 +6843,15 @@ func decodeGetNftItemsByAddressesResponse(resp *http.Response) (res *NftItems, _ } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -5626,7 +6902,7 @@ func decodeGetNftItemsByAddressesResponse(resp *http.Response) (res *NftItems, _ return res, errors.Wrap(defRes, "error") } -func decodeGetOutMsgQueueSizesResponse(resp *http.Response) (res *GetOutMsgQueueSizesOK, _ error) { +func decodeGetPurchaseHistoryResponse(resp *http.Response) (res *AccountPurchases, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -5642,7 +6918,7 @@ func decodeGetOutMsgQueueSizesResponse(resp *http.Response) (res *GetOutMsgQueue } d := jx.DecodeBytes(buf) - var response GetOutMsgQueueSizesOK + var response AccountPurchases if err := func() error { if err := response.Decode(d); err != nil { return err @@ -5659,6 +6935,15 @@ func decodeGetOutMsgQueueSizesResponse(resp *http.Response) (res *GetOutMsgQueue } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -5742,6 +7027,15 @@ func decodeGetRatesResponse(resp *http.Response) (res *GetRatesOK, _ error) { } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -5908,6 +7202,15 @@ func decodeGetRawBlockProofResponse(resp *http.Response) (res *GetRawBlockProofO } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -6489,6 +7792,15 @@ func decodeGetRawListBlockTransactionsResponse(resp *http.Response) (res *GetRaw } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -6738,6 +8050,15 @@ func decodeGetRawShardBlockProofResponse(resp *http.Response) (res *GetRawShardB } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -6987,6 +8308,15 @@ func decodeGetRawTransactionsResponse(resp *http.Response) (res *GetRawTransacti } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -7070,6 +8400,15 @@ func decodeGetReducedBlockchainBlocksResponse(resp *http.Response) (res *Reduced } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -7153,6 +8492,15 @@ func decodeGetStakingPoolHistoryResponse(resp *http.Response) (res *GetStakingPo } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -7236,6 +8584,15 @@ func decodeGetStakingPoolInfoResponse(resp *http.Response) (res *GetStakingPoolI } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -7319,6 +8676,15 @@ func decodeGetStakingPoolsResponse(resp *http.Response) (res *GetStakingPoolsOK, } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -7402,6 +8768,15 @@ func decodeGetStorageProvidersResponse(resp *http.Response) (res *GetStorageProv } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -7568,6 +8943,15 @@ func decodeGetTraceResponse(resp *http.Response) (res *Trace, _ error) { } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -7618,7 +9002,7 @@ func decodeGetTraceResponse(resp *http.Response) (res *Trace, _ error) { return res, errors.Wrap(defRes, "error") } -func decodeGetWalletBackupResponse(resp *http.Response) (res *GetWalletBackupOK, _ error) { +func decodeGetWalletInfoResponse(resp *http.Response) (res *Wallet, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -7634,7 +9018,7 @@ func decodeGetWalletBackupResponse(resp *http.Response) (res *GetWalletBackupOK, } d := jx.DecodeBytes(buf) - var response GetWalletBackupOK + var response Wallet if err := func() error { if err := response.Decode(d); err != nil { return err @@ -7651,6 +9035,15 @@ func decodeGetWalletBackupResponse(resp *http.Response) (res *GetWalletBackupOK, } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -7701,7 +9094,7 @@ func decodeGetWalletBackupResponse(resp *http.Response) (res *GetWalletBackupOK, return res, errors.Wrap(defRes, "error") } -func decodeGetWalletsByPublicKeyResponse(resp *http.Response) (res *Accounts, _ error) { +func decodeGetWalletsByPublicKeyResponse(resp *http.Response) (res *Wallets, _ error) { switch resp.StatusCode { case 200: // Code 200. @@ -7717,7 +9110,7 @@ func decodeGetWalletsByPublicKeyResponse(resp *http.Response) (res *Accounts, _ } d := jx.DecodeBytes(buf) - var response Accounts + var response Wallets if err := func() error { if err := response.Decode(d); err != nil { return err @@ -7734,6 +9127,15 @@ func decodeGetWalletsByPublicKeyResponse(resp *http.Response) (res *Accounts, _ } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -7868,6 +9270,15 @@ func decodeSearchAccountsResponse(resp *http.Response) (res *FoundAccounts, _ er } return res, err } + // Validate response. + if err := func() error { + if err := response.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + return res, errors.Wrap(err, "validate") + } return &response, nil default: return res, validate.InvalidContentType(ct) @@ -8052,57 +9463,6 @@ func decodeSendRawMessageResponse(resp *http.Response) (res *SendRawMessageOK, _ return res, errors.Wrap(defRes, "error") } -func decodeSetWalletBackupResponse(resp *http.Response) (res *SetWalletBackupOK, _ error) { - switch resp.StatusCode { - case 200: - // Code 200. - return &SetWalletBackupOK{}, nil - } - // 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 decodeStatusResponse(resp *http.Response) (res *ServiceStatus, _ error) { switch resp.StatusCode { case 200: diff --git a/oas_schemas_gen.go b/oas_schemas_gen.go index 7a494bf..0aff672 100644 --- a/oas_schemas_gen.go +++ b/oas_schemas_gen.go @@ -65,8 +65,9 @@ func (s *AccStatusChange) UnmarshalText(data []byte) error { // Ref: #/components/schemas/Account type Account struct { - Address string `json:"address"` - Balance int64 `json:"balance"` + Address string `json:"address"` + Balance int64 `json:"balance"` + ExtraBalance []ExtraCurrency `json:"extra_balance"` // {'USD': 1, 'IDR': 1000}. CurrenciesBalance OptAccountCurrenciesBalance `json:"currencies_balance"` // Unix timestamp. @@ -92,6 +93,11 @@ func (s *Account) GetBalance() int64 { return s.Balance } +// GetExtraBalance returns the value of ExtraBalance. +func (s *Account) GetExtraBalance() []ExtraCurrency { + return s.ExtraBalance +} + // GetCurrenciesBalance returns the value of CurrenciesBalance. func (s *Account) GetCurrenciesBalance() OptAccountCurrenciesBalance { return s.CurrenciesBalance @@ -157,6 +163,11 @@ func (s *Account) SetBalance(val int64) { s.Balance = val } +// SetExtraBalance sets the value of ExtraBalance. +func (s *Account) SetExtraBalance(val []ExtraCurrency) { + s.ExtraBalance = val +} + // SetCurrenciesBalance sets the value of CurrenciesBalance. func (s *Account) SetCurrenciesBalance(val OptAccountCurrenciesBalance) { s.CurrenciesBalance = val @@ -303,7 +314,8 @@ type AccountEvent struct { // Event is not finished yet. Transactions still happening. InProgress bool `json:"in_progress"` // TODO. - Extra int64 `json:"extra"` + Extra int64 `json:"extra"` + Progress float32 `json:"progress"` } // GetEventID returns the value of EventID. @@ -346,6 +358,11 @@ func (s *AccountEvent) GetExtra() int64 { return s.Extra } +// GetProgress returns the value of Progress. +func (s *AccountEvent) GetProgress() float32 { + return s.Progress +} + // SetEventID sets the value of EventID. func (s *AccountEvent) SetEventID(val string) { s.EventID = val @@ -386,6 +403,11 @@ func (s *AccountEvent) SetExtra(val int64) { s.Extra = val } +// SetProgress sets the value of Progress. +func (s *AccountEvent) SetProgress(val float32) { + s.Progress = val +} + // Ref: #/components/schemas/AccountEvents type AccountEvents struct { Events []AccountEvent `json:"events"` @@ -438,6 +460,32 @@ func (s *AccountInfoByStateInit) SetAddress(val string) { s.Address = val } +// Ref: #/components/schemas/AccountPurchases +type AccountPurchases struct { + Purchases []Purchase `json:"purchases"` + NextFrom int64 `json:"next_from"` +} + +// GetPurchases returns the value of Purchases. +func (s *AccountPurchases) GetPurchases() []Purchase { + return s.Purchases +} + +// GetNextFrom returns the value of NextFrom. +func (s *AccountPurchases) GetNextFrom() int64 { + return s.NextFrom +} + +// SetPurchases sets the value of Purchases. +func (s *AccountPurchases) SetPurchases(val []Purchase) { + s.Purchases = val +} + +// SetNextFrom sets the value of NextFrom. +func (s *AccountPurchases) SetNextFrom(val int64) { + s.NextFrom = val +} + // Ref: #/components/schemas/AccountStaking type AccountStaking struct { Pools []AccountStakingInfo `json:"pools"` @@ -645,30 +693,37 @@ func (s *Accounts) SetAccounts(val []Account) { // Ref: #/components/schemas/Action type Action struct { - Type ActionType `json:"type"` - Status ActionStatus `json:"status"` - TonTransfer OptTonTransferAction `json:"TonTransfer"` - ContractDeploy OptContractDeployAction `json:"ContractDeploy"` - JettonTransfer OptJettonTransferAction `json:"JettonTransfer"` - JettonBurn OptJettonBurnAction `json:"JettonBurn"` - JettonMint OptJettonMintAction `json:"JettonMint"` - NftItemTransfer OptNftItemTransferAction `json:"NftItemTransfer"` - Subscribe OptSubscriptionAction `json:"Subscribe"` - UnSubscribe OptUnSubscriptionAction `json:"UnSubscribe"` - AuctionBid OptAuctionBidAction `json:"AuctionBid"` - NftPurchase OptNftPurchaseAction `json:"NftPurchase"` - DepositStake OptDepositStakeAction `json:"DepositStake"` - WithdrawStake OptWithdrawStakeAction `json:"WithdrawStake"` - WithdrawStakeRequest OptWithdrawStakeRequestAction `json:"WithdrawStakeRequest"` - ElectionsDepositStake OptElectionsDepositStakeAction `json:"ElectionsDepositStake"` - ElectionsRecoverStake OptElectionsRecoverStakeAction `json:"ElectionsRecoverStake"` - JettonSwap OptJettonSwapAction `json:"JettonSwap"` - SmartContractExec OptSmartContractAction `json:"SmartContractExec"` - DomainRenew OptDomainRenewAction `json:"DomainRenew"` - InscriptionTransfer OptInscriptionTransferAction `json:"InscriptionTransfer"` - InscriptionMint OptInscriptionMintAction `json:"InscriptionMint"` - SimplePreview ActionSimplePreview `json:"simple_preview"` - BaseTransactions []string `json:"base_transactions"` + Type ActionType `json:"type"` + Status ActionStatus `json:"status"` + TonTransfer OptTonTransferAction `json:"TonTransfer"` + ExtraCurrencyTransfer OptExtraCurrencyTransferAction `json:"ExtraCurrencyTransfer"` + ContractDeploy OptContractDeployAction `json:"ContractDeploy"` + JettonTransfer OptJettonTransferAction `json:"JettonTransfer"` + JettonBurn OptJettonBurnAction `json:"JettonBurn"` + JettonMint OptJettonMintAction `json:"JettonMint"` + NftItemTransfer OptNftItemTransferAction `json:"NftItemTransfer"` + Subscribe OptSubscriptionAction `json:"Subscribe"` + UnSubscribe OptUnSubscriptionAction `json:"UnSubscribe"` + AuctionBid OptAuctionBidAction `json:"AuctionBid"` + NftPurchase OptNftPurchaseAction `json:"NftPurchase"` + DepositStake OptDepositStakeAction `json:"DepositStake"` + WithdrawStake OptWithdrawStakeAction `json:"WithdrawStake"` + WithdrawStakeRequest OptWithdrawStakeRequestAction `json:"WithdrawStakeRequest"` + ElectionsDepositStake OptElectionsDepositStakeAction `json:"ElectionsDepositStake"` + ElectionsRecoverStake OptElectionsRecoverStakeAction `json:"ElectionsRecoverStake"` + JettonSwap OptJettonSwapAction `json:"JettonSwap"` + SmartContractExec OptSmartContractAction `json:"SmartContractExec"` + DomainRenew OptDomainRenewAction `json:"DomainRenew"` + Purchase OptPurchaseAction `json:"Purchase"` + AddExtension OptAddExtensionAction `json:"AddExtension"` + RemoveExtension OptRemoveExtensionAction `json:"RemoveExtension"` + SetSignatureAllowedAction OptSetSignatureAllowedAction `json:"SetSignatureAllowedAction"` + GasRelay OptGasRelayAction `json:"GasRelay"` + DepositTokenStake OptDepositTokenStakeAction `json:"DepositTokenStake"` + WithdrawTokenStakeRequest OptWithdrawTokenStakeRequestAction `json:"WithdrawTokenStakeRequest"` + LiquidityDeposit OptLiquidityDepositAction `json:"LiquidityDeposit"` + SimplePreview ActionSimplePreview `json:"simple_preview"` + BaseTransactions []string `json:"base_transactions"` } // GetType returns the value of Type. @@ -686,6 +741,11 @@ func (s *Action) GetTonTransfer() OptTonTransferAction { return s.TonTransfer } +// GetExtraCurrencyTransfer returns the value of ExtraCurrencyTransfer. +func (s *Action) GetExtraCurrencyTransfer() OptExtraCurrencyTransferAction { + return s.ExtraCurrencyTransfer +} + // GetContractDeploy returns the value of ContractDeploy. func (s *Action) GetContractDeploy() OptContractDeployAction { return s.ContractDeploy @@ -771,14 +831,44 @@ func (s *Action) GetDomainRenew() OptDomainRenewAction { return s.DomainRenew } -// GetInscriptionTransfer returns the value of InscriptionTransfer. -func (s *Action) GetInscriptionTransfer() OptInscriptionTransferAction { - return s.InscriptionTransfer +// GetPurchase returns the value of Purchase. +func (s *Action) GetPurchase() OptPurchaseAction { + return s.Purchase +} + +// GetAddExtension returns the value of AddExtension. +func (s *Action) GetAddExtension() OptAddExtensionAction { + return s.AddExtension +} + +// GetRemoveExtension returns the value of RemoveExtension. +func (s *Action) GetRemoveExtension() OptRemoveExtensionAction { + return s.RemoveExtension +} + +// GetSetSignatureAllowedAction returns the value of SetSignatureAllowedAction. +func (s *Action) GetSetSignatureAllowedAction() OptSetSignatureAllowedAction { + return s.SetSignatureAllowedAction +} + +// GetGasRelay returns the value of GasRelay. +func (s *Action) GetGasRelay() OptGasRelayAction { + return s.GasRelay +} + +// GetDepositTokenStake returns the value of DepositTokenStake. +func (s *Action) GetDepositTokenStake() OptDepositTokenStakeAction { + return s.DepositTokenStake +} + +// GetWithdrawTokenStakeRequest returns the value of WithdrawTokenStakeRequest. +func (s *Action) GetWithdrawTokenStakeRequest() OptWithdrawTokenStakeRequestAction { + return s.WithdrawTokenStakeRequest } -// GetInscriptionMint returns the value of InscriptionMint. -func (s *Action) GetInscriptionMint() OptInscriptionMintAction { - return s.InscriptionMint +// GetLiquidityDeposit returns the value of LiquidityDeposit. +func (s *Action) GetLiquidityDeposit() OptLiquidityDepositAction { + return s.LiquidityDeposit } // GetSimplePreview returns the value of SimplePreview. @@ -806,6 +896,11 @@ func (s *Action) SetTonTransfer(val OptTonTransferAction) { s.TonTransfer = val } +// SetExtraCurrencyTransfer sets the value of ExtraCurrencyTransfer. +func (s *Action) SetExtraCurrencyTransfer(val OptExtraCurrencyTransferAction) { + s.ExtraCurrencyTransfer = val +} + // SetContractDeploy sets the value of ContractDeploy. func (s *Action) SetContractDeploy(val OptContractDeployAction) { s.ContractDeploy = val @@ -891,14 +986,44 @@ func (s *Action) SetDomainRenew(val OptDomainRenewAction) { s.DomainRenew = val } -// SetInscriptionTransfer sets the value of InscriptionTransfer. -func (s *Action) SetInscriptionTransfer(val OptInscriptionTransferAction) { - s.InscriptionTransfer = val +// SetPurchase sets the value of Purchase. +func (s *Action) SetPurchase(val OptPurchaseAction) { + s.Purchase = val +} + +// SetAddExtension sets the value of AddExtension. +func (s *Action) SetAddExtension(val OptAddExtensionAction) { + s.AddExtension = val +} + +// SetRemoveExtension sets the value of RemoveExtension. +func (s *Action) SetRemoveExtension(val OptRemoveExtensionAction) { + s.RemoveExtension = val +} + +// SetSetSignatureAllowedAction sets the value of SetSignatureAllowedAction. +func (s *Action) SetSetSignatureAllowedAction(val OptSetSignatureAllowedAction) { + s.SetSignatureAllowedAction = val +} + +// SetGasRelay sets the value of GasRelay. +func (s *Action) SetGasRelay(val OptGasRelayAction) { + s.GasRelay = val +} + +// SetDepositTokenStake sets the value of DepositTokenStake. +func (s *Action) SetDepositTokenStake(val OptDepositTokenStakeAction) { + s.DepositTokenStake = val +} + +// SetWithdrawTokenStakeRequest sets the value of WithdrawTokenStakeRequest. +func (s *Action) SetWithdrawTokenStakeRequest(val OptWithdrawTokenStakeRequestAction) { + s.WithdrawTokenStakeRequest = val } -// SetInscriptionMint sets the value of InscriptionMint. -func (s *Action) SetInscriptionMint(val OptInscriptionMintAction) { - s.InscriptionMint = val +// SetLiquidityDeposit sets the value of LiquidityDeposit. +func (s *Action) SetLiquidityDeposit(val OptLiquidityDepositAction) { + s.LiquidityDeposit = val } // SetSimplePreview sets the value of SimplePreview. @@ -1109,38 +1234,46 @@ func (s *ActionStatus) UnmarshalText(data []byte) error { type ActionType string const ( - ActionTypeTonTransfer ActionType = "TonTransfer" - ActionTypeJettonTransfer ActionType = "JettonTransfer" - ActionTypeJettonBurn ActionType = "JettonBurn" - ActionTypeJettonMint ActionType = "JettonMint" - ActionTypeNftItemTransfer ActionType = "NftItemTransfer" - ActionTypeContractDeploy ActionType = "ContractDeploy" - ActionTypeSubscribe ActionType = "Subscribe" - ActionTypeUnSubscribe ActionType = "UnSubscribe" - ActionTypeAuctionBid ActionType = "AuctionBid" - ActionTypeNftPurchase ActionType = "NftPurchase" - ActionTypeDepositStake ActionType = "DepositStake" - ActionTypeWithdrawStake ActionType = "WithdrawStake" - ActionTypeWithdrawStakeRequest ActionType = "WithdrawStakeRequest" - ActionTypeJettonSwap ActionType = "JettonSwap" - ActionTypeSmartContractExec ActionType = "SmartContractExec" - ActionTypeElectionsRecoverStake ActionType = "ElectionsRecoverStake" - ActionTypeElectionsDepositStake ActionType = "ElectionsDepositStake" - ActionTypeDomainRenew ActionType = "DomainRenew" - ActionTypeInscriptionTransfer ActionType = "InscriptionTransfer" - ActionTypeInscriptionMint ActionType = "InscriptionMint" - ActionTypeUnknown ActionType = "Unknown" + ActionTypeTonTransfer ActionType = "TonTransfer" + ActionTypeExtraCurrencyTransfer ActionType = "ExtraCurrencyTransfer" + ActionTypeContractDeploy ActionType = "ContractDeploy" + ActionTypeJettonTransfer ActionType = "JettonTransfer" + ActionTypeJettonBurn ActionType = "JettonBurn" + ActionTypeJettonMint ActionType = "JettonMint" + ActionTypeNftItemTransfer ActionType = "NftItemTransfer" + ActionTypeSubscribe ActionType = "Subscribe" + ActionTypeUnSubscribe ActionType = "UnSubscribe" + ActionTypeAuctionBid ActionType = "AuctionBid" + ActionTypeNftPurchase ActionType = "NftPurchase" + ActionTypeDepositStake ActionType = "DepositStake" + ActionTypeWithdrawStake ActionType = "WithdrawStake" + ActionTypeWithdrawStakeRequest ActionType = "WithdrawStakeRequest" + ActionTypeElectionsDepositStake ActionType = "ElectionsDepositStake" + ActionTypeElectionsRecoverStake ActionType = "ElectionsRecoverStake" + ActionTypeJettonSwap ActionType = "JettonSwap" + ActionTypeSmartContractExec ActionType = "SmartContractExec" + ActionTypeDomainRenew ActionType = "DomainRenew" + ActionTypePurchase ActionType = "Purchase" + ActionTypeAddExtension ActionType = "AddExtension" + ActionTypeRemoveExtension ActionType = "RemoveExtension" + ActionTypeSetSignatureAllowedAction ActionType = "SetSignatureAllowedAction" + ActionTypeGasRelay ActionType = "GasRelay" + ActionTypeDepositTokenStake ActionType = "DepositTokenStake" + ActionTypeWithdrawTokenStakeRequest ActionType = "WithdrawTokenStakeRequest" + ActionTypeLiquidityDeposit ActionType = "LiquidityDeposit" + ActionTypeUnknown ActionType = "Unknown" ) // AllValues returns all ActionType values. func (ActionType) AllValues() []ActionType { return []ActionType{ ActionTypeTonTransfer, + ActionTypeExtraCurrencyTransfer, + ActionTypeContractDeploy, ActionTypeJettonTransfer, ActionTypeJettonBurn, ActionTypeJettonMint, ActionTypeNftItemTransfer, - ActionTypeContractDeploy, ActionTypeSubscribe, ActionTypeUnSubscribe, ActionTypeAuctionBid, @@ -1148,13 +1281,19 @@ func (ActionType) AllValues() []ActionType { ActionTypeDepositStake, ActionTypeWithdrawStake, ActionTypeWithdrawStakeRequest, + ActionTypeElectionsDepositStake, + ActionTypeElectionsRecoverStake, ActionTypeJettonSwap, ActionTypeSmartContractExec, - ActionTypeElectionsRecoverStake, - ActionTypeElectionsDepositStake, ActionTypeDomainRenew, - ActionTypeInscriptionTransfer, - ActionTypeInscriptionMint, + ActionTypePurchase, + ActionTypeAddExtension, + ActionTypeRemoveExtension, + ActionTypeSetSignatureAllowedAction, + ActionTypeGasRelay, + ActionTypeDepositTokenStake, + ActionTypeWithdrawTokenStakeRequest, + ActionTypeLiquidityDeposit, ActionTypeUnknown, } } @@ -1164,6 +1303,10 @@ func (s ActionType) MarshalText() ([]byte, error) { switch s { case ActionTypeTonTransfer: return []byte(s), nil + case ActionTypeExtraCurrencyTransfer: + return []byte(s), nil + case ActionTypeContractDeploy: + return []byte(s), nil case ActionTypeJettonTransfer: return []byte(s), nil case ActionTypeJettonBurn: @@ -1172,8 +1315,6 @@ func (s ActionType) MarshalText() ([]byte, error) { return []byte(s), nil case ActionTypeNftItemTransfer: return []byte(s), nil - case ActionTypeContractDeploy: - return []byte(s), nil case ActionTypeSubscribe: return []byte(s), nil case ActionTypeUnSubscribe: @@ -1188,19 +1329,31 @@ func (s ActionType) MarshalText() ([]byte, error) { return []byte(s), nil case ActionTypeWithdrawStakeRequest: return []byte(s), nil + case ActionTypeElectionsDepositStake: + return []byte(s), nil + case ActionTypeElectionsRecoverStake: + return []byte(s), nil case ActionTypeJettonSwap: return []byte(s), nil case ActionTypeSmartContractExec: return []byte(s), nil - case ActionTypeElectionsRecoverStake: + case ActionTypeDomainRenew: return []byte(s), nil - case ActionTypeElectionsDepositStake: + case ActionTypePurchase: return []byte(s), nil - case ActionTypeDomainRenew: + case ActionTypeAddExtension: + return []byte(s), nil + case ActionTypeRemoveExtension: + return []byte(s), nil + case ActionTypeSetSignatureAllowedAction: return []byte(s), nil - case ActionTypeInscriptionTransfer: + case ActionTypeGasRelay: return []byte(s), nil - case ActionTypeInscriptionMint: + case ActionTypeDepositTokenStake: + return []byte(s), nil + case ActionTypeWithdrawTokenStakeRequest: + return []byte(s), nil + case ActionTypeLiquidityDeposit: return []byte(s), nil case ActionTypeUnknown: return []byte(s), nil @@ -1215,6 +1368,12 @@ func (s *ActionType) UnmarshalText(data []byte) error { case ActionTypeTonTransfer: *s = ActionTypeTonTransfer return nil + case ActionTypeExtraCurrencyTransfer: + *s = ActionTypeExtraCurrencyTransfer + return nil + case ActionTypeContractDeploy: + *s = ActionTypeContractDeploy + return nil case ActionTypeJettonTransfer: *s = ActionTypeJettonTransfer return nil @@ -1227,9 +1386,6 @@ func (s *ActionType) UnmarshalText(data []byte) error { case ActionTypeNftItemTransfer: *s = ActionTypeNftItemTransfer return nil - case ActionTypeContractDeploy: - *s = ActionTypeContractDeploy - return nil case ActionTypeSubscribe: *s = ActionTypeSubscribe return nil @@ -1251,26 +1407,44 @@ func (s *ActionType) UnmarshalText(data []byte) error { case ActionTypeWithdrawStakeRequest: *s = ActionTypeWithdrawStakeRequest return nil + case ActionTypeElectionsDepositStake: + *s = ActionTypeElectionsDepositStake + return nil + case ActionTypeElectionsRecoverStake: + *s = ActionTypeElectionsRecoverStake + return nil case ActionTypeJettonSwap: *s = ActionTypeJettonSwap return nil case ActionTypeSmartContractExec: *s = ActionTypeSmartContractExec return nil - case ActionTypeElectionsRecoverStake: - *s = ActionTypeElectionsRecoverStake - return nil - case ActionTypeElectionsDepositStake: - *s = ActionTypeElectionsDepositStake - return nil case ActionTypeDomainRenew: *s = ActionTypeDomainRenew return nil - case ActionTypeInscriptionTransfer: - *s = ActionTypeInscriptionTransfer + case ActionTypePurchase: + *s = ActionTypePurchase + return nil + case ActionTypeAddExtension: + *s = ActionTypeAddExtension + return nil + case ActionTypeRemoveExtension: + *s = ActionTypeRemoveExtension + return nil + case ActionTypeSetSignatureAllowedAction: + *s = ActionTypeSetSignatureAllowedAction return nil - case ActionTypeInscriptionMint: - *s = ActionTypeInscriptionMint + case ActionTypeGasRelay: + *s = ActionTypeGasRelay + return nil + case ActionTypeDepositTokenStake: + *s = ActionTypeDepositTokenStake + return nil + case ActionTypeWithdrawTokenStakeRequest: + *s = ActionTypeWithdrawTokenStakeRequest + return nil + case ActionTypeLiquidityDeposit: + *s = ActionTypeLiquidityDeposit return nil case ActionTypeUnknown: *s = ActionTypeUnknown @@ -1280,6 +1454,32 @@ func (s *ActionType) UnmarshalText(data []byte) error { } } +// Ref: #/components/schemas/AddExtensionAction +type AddExtensionAction struct { + Wallet AccountAddress `json:"wallet"` + Extension string `json:"extension"` +} + +// GetWallet returns the value of Wallet. +func (s *AddExtensionAction) GetWallet() AccountAddress { + return s.Wallet +} + +// GetExtension returns the value of Extension. +func (s *AddExtensionAction) GetExtension() string { + return s.Extension +} + +// SetWallet sets the value of Wallet. +func (s *AddExtensionAction) SetWallet(val AccountAddress) { + s.Wallet = val +} + +// SetExtension sets the value of Extension. +func (s *AddExtensionAction) SetExtension(val string) { + s.Extension = val +} + type AddressParseOK struct { RawForm string `json:"raw_form"` Bounceable AddressParseOKBounceable `json:"bounceable"` @@ -1613,6 +1813,20 @@ func (s *Auctions) SetTotal(val int64) { s.Total = val } +type BearerAuth struct { + Token string +} + +// GetToken returns the value of Token. +func (s *BearerAuth) GetToken() string { + return s.Token +} + +// SetToken sets the value of Token. +func (s *BearerAuth) SetToken(val string) { + s.Token = val +} + // Ref: #/components/schemas/BlockCurrencyCollection type BlockCurrencyCollection struct { Grams int64 `json:"grams"` @@ -1913,10 +2127,12 @@ func (s *BlockValueFlow) SetMinted(val BlockCurrencyCollection) { // Ref: #/components/schemas/BlockchainAccountInspect type BlockchainAccountInspect struct { - Code string `json:"code"` - CodeHash string `json:"code_hash"` - Methods []BlockchainAccountInspectMethodsItem `json:"methods"` - Compiler OptBlockchainAccountInspectCompiler `json:"compiler"` + Code string `json:"code"` + DisassembledCode OptString `json:"disassembled_code"` + CodeHash string `json:"code_hash"` + Methods []Method `json:"methods"` + Compiler BlockchainAccountInspectCompiler `json:"compiler"` + Source OptSource `json:"source"` } // GetCode returns the value of Code. @@ -1924,51 +2140,75 @@ func (s *BlockchainAccountInspect) GetCode() string { return s.Code } +// GetDisassembledCode returns the value of DisassembledCode. +func (s *BlockchainAccountInspect) GetDisassembledCode() OptString { + return s.DisassembledCode +} + // GetCodeHash returns the value of CodeHash. func (s *BlockchainAccountInspect) GetCodeHash() string { return s.CodeHash } // GetMethods returns the value of Methods. -func (s *BlockchainAccountInspect) GetMethods() []BlockchainAccountInspectMethodsItem { +func (s *BlockchainAccountInspect) GetMethods() []Method { return s.Methods } // GetCompiler returns the value of Compiler. -func (s *BlockchainAccountInspect) GetCompiler() OptBlockchainAccountInspectCompiler { +func (s *BlockchainAccountInspect) GetCompiler() BlockchainAccountInspectCompiler { return s.Compiler } +// GetSource returns the value of Source. +func (s *BlockchainAccountInspect) GetSource() OptSource { + return s.Source +} + // SetCode sets the value of Code. func (s *BlockchainAccountInspect) SetCode(val string) { s.Code = val } +// SetDisassembledCode sets the value of DisassembledCode. +func (s *BlockchainAccountInspect) SetDisassembledCode(val OptString) { + s.DisassembledCode = val +} + // SetCodeHash sets the value of CodeHash. func (s *BlockchainAccountInspect) SetCodeHash(val string) { s.CodeHash = val } // SetMethods sets the value of Methods. -func (s *BlockchainAccountInspect) SetMethods(val []BlockchainAccountInspectMethodsItem) { +func (s *BlockchainAccountInspect) SetMethods(val []Method) { s.Methods = val } // SetCompiler sets the value of Compiler. -func (s *BlockchainAccountInspect) SetCompiler(val OptBlockchainAccountInspectCompiler) { +func (s *BlockchainAccountInspect) SetCompiler(val BlockchainAccountInspectCompiler) { s.Compiler = val } +// SetSource sets the value of Source. +func (s *BlockchainAccountInspect) SetSource(val OptSource) { + s.Source = val +} + type BlockchainAccountInspectCompiler string const ( BlockchainAccountInspectCompilerFunc BlockchainAccountInspectCompiler = "func" + BlockchainAccountInspectCompilerFift BlockchainAccountInspectCompiler = "fift" + BlockchainAccountInspectCompilerTact BlockchainAccountInspectCompiler = "tact" ) // AllValues returns all BlockchainAccountInspectCompiler values. func (BlockchainAccountInspectCompiler) AllValues() []BlockchainAccountInspectCompiler { return []BlockchainAccountInspectCompiler{ BlockchainAccountInspectCompilerFunc, + BlockchainAccountInspectCompilerFift, + BlockchainAccountInspectCompilerTact, } } @@ -1977,6 +2217,10 @@ func (s BlockchainAccountInspectCompiler) MarshalText() ([]byte, error) { switch s { case BlockchainAccountInspectCompilerFunc: return []byte(s), nil + case BlockchainAccountInspectCompilerFift: + return []byte(s), nil + case BlockchainAccountInspectCompilerTact: + return []byte(s), nil default: return nil, errors.Errorf("invalid value: %q", s) } @@ -1988,36 +2232,17 @@ func (s *BlockchainAccountInspectCompiler) UnmarshalText(data []byte) error { case BlockchainAccountInspectCompilerFunc: *s = BlockchainAccountInspectCompilerFunc return nil + case BlockchainAccountInspectCompilerFift: + *s = BlockchainAccountInspectCompilerFift + return nil + case BlockchainAccountInspectCompilerTact: + *s = BlockchainAccountInspectCompilerTact + return nil default: return errors.Errorf("invalid value: %q", data) } } -type BlockchainAccountInspectMethodsItem struct { - ID int64 `json:"id"` - Method string `json:"method"` -} - -// GetID returns the value of ID. -func (s *BlockchainAccountInspectMethodsItem) GetID() int64 { - return s.ID -} - -// GetMethod returns the value of Method. -func (s *BlockchainAccountInspectMethodsItem) GetMethod() string { - return s.Method -} - -// SetID sets the value of ID. -func (s *BlockchainAccountInspectMethodsItem) SetID(val int64) { - s.ID = val -} - -// SetMethod sets the value of Method. -func (s *BlockchainAccountInspectMethodsItem) SetMethod(val string) { - s.Method = val -} - // Ref: #/components/schemas/BlockchainBlock type BlockchainBlock struct { TxQuantity int `json:"tx_quantity"` @@ -2485,6 +2710,8 @@ type BlockchainConfig struct { R43 OptBlockchainConfig43 `json:"43"` // Suspended accounts. R44 BlockchainConfig44 `json:"44"` + // Precompiled contracts. + R45 OptBlockchainConfig45 `json:"45"` // Bridge parameters for wrapping TON in other networks. R71 OptBlockchainConfig71 `json:"71"` // Bridge parameters for wrapping TON in other networks. @@ -2689,6 +2916,11 @@ func (s *BlockchainConfig) GetR44() BlockchainConfig44 { return s.R44 } +// GetR45 returns the value of R45. +func (s *BlockchainConfig) GetR45() OptBlockchainConfig45 { + return s.R45 +} + // GetR71 returns the value of R71. func (s *BlockchainConfig) GetR71() OptBlockchainConfig71 { return s.R71 @@ -2909,6 +3141,11 @@ func (s *BlockchainConfig) SetR44(val BlockchainConfig44) { s.R44 = val } +// SetR45 sets the value of R45. +func (s *BlockchainConfig) SetR45(val OptBlockchainConfig45) { + s.R45 = val +} + // SetR71 sets the value of R71. func (s *BlockchainConfig) SetR71(val OptBlockchainConfig71) { s.R71 = val @@ -3638,6 +3875,46 @@ func (s *BlockchainConfig44) SetSuspendedUntil(val int) { s.SuspendedUntil = val } +// Precompiled contracts. +type BlockchainConfig45 struct { + Contracts []BlockchainConfig45ContractsItem `json:"contracts"` +} + +// GetContracts returns the value of Contracts. +func (s *BlockchainConfig45) GetContracts() []BlockchainConfig45ContractsItem { + return s.Contracts +} + +// SetContracts sets the value of Contracts. +func (s *BlockchainConfig45) SetContracts(val []BlockchainConfig45ContractsItem) { + s.Contracts = val +} + +type BlockchainConfig45ContractsItem struct { + CodeHash string `json:"code_hash"` + GasUsage int64 `json:"gas_usage"` +} + +// GetCodeHash returns the value of CodeHash. +func (s *BlockchainConfig45ContractsItem) GetCodeHash() string { + return s.CodeHash +} + +// GetGasUsage returns the value of GasUsage. +func (s *BlockchainConfig45ContractsItem) GetGasUsage() int64 { + return s.GasUsage +} + +// SetCodeHash sets the value of CodeHash. +func (s *BlockchainConfig45ContractsItem) SetCodeHash(val string) { + s.CodeHash = val +} + +// SetGasUsage sets the value of GasUsage. +func (s *BlockchainConfig45ContractsItem) SetGasUsage(val int64) { + s.GasUsage = val +} + type BlockchainConfig5 struct { BlackholeAddr OptString `json:"blackhole_addr"` FeeBurnNom int64 `json:"fee_burn_nom"` @@ -3871,11 +4148,26 @@ func (s *BlockchainConfig9) SetMandatoryParams(val []int32) { s.MandatoryParams = val } +// Ref: #/components/schemas/BlockchainLibrary +type BlockchainLibrary struct { + Boc string `json:"boc"` +} + +// GetBoc returns the value of Boc. +func (s *BlockchainLibrary) GetBoc() string { + return s.Boc +} + +// SetBoc sets the value of Boc. +func (s *BlockchainLibrary) SetBoc(val string) { + s.Boc = val +} + // Ref: #/components/schemas/BlockchainRawAccount type BlockchainRawAccount struct { Address string `json:"address"` Balance int64 `json:"balance"` - ExtraBalance OptBlockchainRawAccountExtraBalance `json:"extra_balance"` + ExtraBalance []ExtraCurrency `json:"extra_balance"` Code OptString `json:"code"` Data OptString `json:"data"` LastTransactionLt int64 `json:"last_transaction_lt"` @@ -3897,7 +4189,7 @@ func (s *BlockchainRawAccount) GetBalance() int64 { } // GetExtraBalance returns the value of ExtraBalance. -func (s *BlockchainRawAccount) GetExtraBalance() OptBlockchainRawAccountExtraBalance { +func (s *BlockchainRawAccount) GetExtraBalance() []ExtraCurrency { return s.ExtraBalance } @@ -3952,7 +4244,7 @@ func (s *BlockchainRawAccount) SetBalance(val int64) { } // SetExtraBalance sets the value of ExtraBalance. -func (s *BlockchainRawAccount) SetExtraBalance(val OptBlockchainRawAccountExtraBalance) { +func (s *BlockchainRawAccount) SetExtraBalance(val []ExtraCurrency) { s.ExtraBalance = val } @@ -3996,17 +4288,6 @@ func (s *BlockchainRawAccount) SetLibraries(val []BlockchainRawAccountLibrariesI s.Libraries = val } -type BlockchainRawAccountExtraBalance map[string]string - -func (s *BlockchainRawAccountExtraBalance) init() BlockchainRawAccountExtraBalance { - m := *s - if m == nil { - m = map[string]string{} - *s = m - } - return m -} - type BlockchainRawAccountLibrariesItem struct { Public bool `json:"public"` Root string `json:"root"` @@ -4081,6 +4362,8 @@ func (s *BouncePhaseType) UnmarshalText(data []byte) error { } } +type ChartPoints [][]float64 + // Ref: #/components/schemas/ComputePhase type ComputePhase struct { Skipped bool `json:"skipped"` @@ -4177,9 +4460,10 @@ func (s *ComputePhase) SetExitCodeDescription(val OptString) { type ComputeSkipReason string const ( - ComputeSkipReasonCskipNoState ComputeSkipReason = "cskip_no_state" - ComputeSkipReasonCskipBadState ComputeSkipReason = "cskip_bad_state" - ComputeSkipReasonCskipNoGas ComputeSkipReason = "cskip_no_gas" + ComputeSkipReasonCskipNoState ComputeSkipReason = "cskip_no_state" + ComputeSkipReasonCskipBadState ComputeSkipReason = "cskip_bad_state" + ComputeSkipReasonCskipNoGas ComputeSkipReason = "cskip_no_gas" + ComputeSkipReasonCskipSuspended ComputeSkipReason = "cskip_suspended" ) // AllValues returns all ComputeSkipReason values. @@ -4188,6 +4472,7 @@ func (ComputeSkipReason) AllValues() []ComputeSkipReason { ComputeSkipReasonCskipNoState, ComputeSkipReasonCskipBadState, ComputeSkipReasonCskipNoGas, + ComputeSkipReasonCskipSuspended, } } @@ -4200,6 +4485,8 @@ func (s ComputeSkipReason) MarshalText() ([]byte, error) { return []byte(s), nil case ComputeSkipReasonCskipNoGas: return []byte(s), nil + case ComputeSkipReasonCskipSuspended: + return []byte(s), nil default: return nil, errors.Errorf("invalid value: %q", s) } @@ -4217,6 +4504,9 @@ func (s *ComputeSkipReason) UnmarshalText(data []byte) error { case ComputeSkipReasonCskipNoGas: *s = ComputeSkipReasonCskipNoGas return nil + case ComputeSkipReasonCskipSuspended: + *s = ComputeSkipReasonCskipSuspended + return nil default: return errors.Errorf("invalid value: %q", data) } @@ -4366,6 +4656,62 @@ func (s *CreditPhase) SetCredit(val int64) { s.Credit = val } +// Ref: #/components/schemas/CurrencyType +type CurrencyType string + +const ( + CurrencyTypeNative CurrencyType = "native" + CurrencyTypeExtraCurrency CurrencyType = "extra_currency" + CurrencyTypeJetton CurrencyType = "jetton" + CurrencyTypeFiat CurrencyType = "fiat" +) + +// AllValues returns all CurrencyType values. +func (CurrencyType) AllValues() []CurrencyType { + return []CurrencyType{ + CurrencyTypeNative, + CurrencyTypeExtraCurrency, + CurrencyTypeJetton, + CurrencyTypeFiat, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s CurrencyType) MarshalText() ([]byte, error) { + switch s { + case CurrencyTypeNative: + return []byte(s), nil + case CurrencyTypeExtraCurrency: + return []byte(s), nil + case CurrencyTypeJetton: + return []byte(s), nil + case CurrencyTypeFiat: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *CurrencyType) UnmarshalText(data []byte) error { + switch CurrencyType(data) { + case CurrencyTypeNative: + *s = CurrencyTypeNative + return nil + case CurrencyTypeExtraCurrency: + *s = CurrencyTypeExtraCurrency + return nil + case CurrencyTypeJetton: + *s = CurrencyTypeJetton + return nil + case CurrencyTypeFiat: + *s = CurrencyTypeFiat + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + type DecodeMessageReq struct { Boc string `json:"boc"` } @@ -4420,6 +4766,7 @@ func (s *DecodedMessage) SetExtInMsgDecoded(val OptDecodedMessageExtInMsgDecoded type DecodedMessageExtInMsgDecoded struct { WalletV3 OptDecodedMessageExtInMsgDecodedWalletV3 `json:"wallet_v3"` WalletV4 OptDecodedMessageExtInMsgDecodedWalletV4 `json:"wallet_v4"` + WalletV5 OptDecodedMessageExtInMsgDecodedWalletV5 `json:"wallet_v5"` WalletHighloadV2 OptDecodedMessageExtInMsgDecodedWalletHighloadV2 `json:"wallet_highload_v2"` } @@ -4433,6 +4780,11 @@ func (s *DecodedMessageExtInMsgDecoded) GetWalletV4() OptDecodedMessageExtInMsgD return s.WalletV4 } +// GetWalletV5 returns the value of WalletV5. +func (s *DecodedMessageExtInMsgDecoded) GetWalletV5() OptDecodedMessageExtInMsgDecodedWalletV5 { + return s.WalletV5 +} + // GetWalletHighloadV2 returns the value of WalletHighloadV2. func (s *DecodedMessageExtInMsgDecoded) GetWalletHighloadV2() OptDecodedMessageExtInMsgDecodedWalletHighloadV2 { return s.WalletHighloadV2 @@ -4448,6 +4800,11 @@ func (s *DecodedMessageExtInMsgDecoded) SetWalletV4(val OptDecodedMessageExtInMs s.WalletV4 = val } +// SetWalletV5 sets the value of WalletV5. +func (s *DecodedMessageExtInMsgDecoded) SetWalletV5(val OptDecodedMessageExtInMsgDecodedWalletV5) { + s.WalletV5 = val +} + // SetWalletHighloadV2 sets the value of WalletHighloadV2. func (s *DecodedMessageExtInMsgDecoded) SetWalletHighloadV2(val OptDecodedMessageExtInMsgDecodedWalletHighloadV2) { s.WalletHighloadV2 = val @@ -4594,20 +4951,45 @@ func (s *DecodedMessageExtInMsgDecodedWalletV4) SetRawMessages(val []DecodedRawM s.RawMessages = val } -// Ref: #/components/schemas/DecodedRawMessage -type DecodedRawMessage struct { - Message DecodedRawMessageMessage `json:"message"` - Mode int `json:"mode"` +type DecodedMessageExtInMsgDecodedWalletV5 struct { + ValidUntil int64 `json:"valid_until"` + RawMessages []DecodedRawMessage `json:"raw_messages"` } -// GetMessage returns the value of Message. -func (s *DecodedRawMessage) GetMessage() DecodedRawMessageMessage { - return s.Message +// GetValidUntil returns the value of ValidUntil. +func (s *DecodedMessageExtInMsgDecodedWalletV5) GetValidUntil() int64 { + return s.ValidUntil } -// GetMode returns the value of Mode. -func (s *DecodedRawMessage) GetMode() int { - return s.Mode +// GetRawMessages returns the value of RawMessages. +func (s *DecodedMessageExtInMsgDecodedWalletV5) GetRawMessages() []DecodedRawMessage { + return s.RawMessages +} + +// SetValidUntil sets the value of ValidUntil. +func (s *DecodedMessageExtInMsgDecodedWalletV5) SetValidUntil(val int64) { + s.ValidUntil = val +} + +// SetRawMessages sets the value of RawMessages. +func (s *DecodedMessageExtInMsgDecodedWalletV5) 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. @@ -4716,6 +5098,43 @@ func (s *DepositStakeAction) SetImplementation(val PoolImplementationType) { s.Implementation = val } +// Ref: #/components/schemas/DepositTokenStakeAction +type DepositTokenStakeAction struct { + Staker AccountAddress `json:"staker"` + Protocol Protocol `json:"protocol"` + StakeMeta OptPrice `json:"stake_meta"` +} + +// GetStaker returns the value of Staker. +func (s *DepositTokenStakeAction) GetStaker() AccountAddress { + return s.Staker +} + +// GetProtocol returns the value of Protocol. +func (s *DepositTokenStakeAction) GetProtocol() Protocol { + return s.Protocol +} + +// GetStakeMeta returns the value of StakeMeta. +func (s *DepositTokenStakeAction) GetStakeMeta() OptPrice { + return s.StakeMeta +} + +// SetStaker sets the value of Staker. +func (s *DepositTokenStakeAction) SetStaker(val AccountAddress) { + s.Staker = val +} + +// SetProtocol sets the value of Protocol. +func (s *DepositTokenStakeAction) SetProtocol(val Protocol) { + s.Protocol = val +} + +// SetStakeMeta sets the value of StakeMeta. +func (s *DepositTokenStakeAction) SetStakeMeta(val OptPrice) { + s.StakeMeta = val +} + // Ref: #/components/schemas/DnsExpiring type DnsExpiring struct { Items []DnsExpiringItemsItem `json:"items"` @@ -4980,6 +5399,94 @@ func (s *DomainRenewAction) SetRenewer(val AccountAddress) { s.Renewer = val } +type DownloadBlockchainBlockBocOK struct { + Data io.Reader +} + +// Read reads data from the Data reader. +// +// Kept to satisfy the io.Reader interface. +func (s DownloadBlockchainBlockBocOK) Read(p []byte) (n int, err error) { + if s.Data == nil { + return 0, io.EOF + } + return s.Data.Read(p) +} + +// DownloadBlockchainBlockBocOKHeaders wraps DownloadBlockchainBlockBocOK with response headers. +type DownloadBlockchainBlockBocOKHeaders struct { + ContentDisposition OptString + Response DownloadBlockchainBlockBocOK +} + +// GetContentDisposition returns the value of ContentDisposition. +func (s *DownloadBlockchainBlockBocOKHeaders) GetContentDisposition() OptString { + return s.ContentDisposition +} + +// GetResponse returns the value of Response. +func (s *DownloadBlockchainBlockBocOKHeaders) GetResponse() DownloadBlockchainBlockBocOK { + return s.Response +} + +// SetContentDisposition sets the value of ContentDisposition. +func (s *DownloadBlockchainBlockBocOKHeaders) SetContentDisposition(val OptString) { + s.ContentDisposition = val +} + +// SetResponse sets the value of Response. +func (s *DownloadBlockchainBlockBocOKHeaders) SetResponse(val DownloadBlockchainBlockBocOK) { + s.Response = val +} + +// Ref: #/components/schemas/EcPreview +type EcPreview struct { + ID int32 `json:"id"` + Symbol string `json:"symbol"` + Decimals int `json:"decimals"` + Image string `json:"image"` +} + +// GetID returns the value of ID. +func (s *EcPreview) GetID() int32 { + return s.ID +} + +// GetSymbol returns the value of Symbol. +func (s *EcPreview) GetSymbol() string { + return s.Symbol +} + +// GetDecimals returns the value of Decimals. +func (s *EcPreview) GetDecimals() int { + return s.Decimals +} + +// GetImage returns the value of Image. +func (s *EcPreview) GetImage() string { + return s.Image +} + +// SetID sets the value of ID. +func (s *EcPreview) SetID(val int32) { + s.ID = val +} + +// SetSymbol sets the value of Symbol. +func (s *EcPreview) SetSymbol(val string) { + s.Symbol = val +} + +// SetDecimals sets the value of Decimals. +func (s *EcPreview) SetDecimals(val int) { + s.Decimals = val +} + +// SetImage sets the value of Image. +func (s *EcPreview) SetImage(val string) { + s.Image = val +} + // Ref: #/components/schemas/ElectionsDepositStakeAction type ElectionsDepositStakeAction struct { Amount int64 `json:"amount"` @@ -5152,7 +5659,8 @@ func (s *EncryptedComment) SetCipherText(val string) { } type Error struct { - Error string `json:"error"` + Error string `json:"error"` + ErrorCode OptInt64 `json:"error_code"` } // GetError returns the value of Error. @@ -5160,11 +5668,21 @@ func (s *Error) GetError() string { return s.Error } +// GetErrorCode returns the value of ErrorCode. +func (s *Error) GetErrorCode() OptInt64 { + return s.ErrorCode +} + // SetError sets the value of Error. func (s *Error) SetError(val string) { s.Error = val } +// SetErrorCode sets the value of ErrorCode. +func (s *Error) SetErrorCode(val OptInt64) { + s.ErrorCode = val +} + // ErrorStatusCode wraps Error with StatusCode. type ErrorStatusCode struct { StatusCode int @@ -5201,7 +5719,8 @@ type Event struct { IsScam bool `json:"is_scam"` Lt int64 `json:"lt"` // Event is not finished yet. Transactions still happening. - InProgress bool `json:"in_progress"` + InProgress bool `json:"in_progress"` + Progress float32 `json:"progress"` } // GetEventID returns the value of EventID. @@ -5239,6 +5758,11 @@ func (s *Event) GetInProgress() bool { return s.InProgress } +// GetProgress returns the value of Progress. +func (s *Event) GetProgress() float32 { + return s.Progress +} + // SetEventID sets the value of EventID. func (s *Event) SetEventID(val string) { s.EventID = val @@ -5274,6 +5798,234 @@ func (s *Event) SetInProgress(val bool) { s.InProgress = val } +// SetProgress sets the value of Progress. +func (s *Event) SetProgress(val float32) { + s.Progress = val +} + +// Ref: #/components/schemas/ExecGetMethodArg +type ExecGetMethodArg struct { + Type ExecGetMethodArgType `json:"type"` + // String representation of the value according to the specified type. + Value string `json:"value"` +} + +// GetType returns the value of Type. +func (s *ExecGetMethodArg) GetType() ExecGetMethodArgType { + return s.Type +} + +// GetValue returns the value of Value. +func (s *ExecGetMethodArg) GetValue() string { + return s.Value +} + +// SetType sets the value of Type. +func (s *ExecGetMethodArg) SetType(val ExecGetMethodArgType) { + s.Type = val +} + +// SetValue sets the value of Value. +func (s *ExecGetMethodArg) SetValue(val string) { + s.Value = val +} + +// Data type of the argument value: +// - `nan`: Not-a-Number value +// - `null`: Null value +// - `tinyint`: Decimal integer (e.g., `100500`) +// - `int257`: 257-bit integer in hex format with 0x prefix (e.g., `0xfa01d78381ae32`) +// - `slice`: TON blockchain address (e.g., `0:6e731f2e...`) +// - `cell_boc_base64`: Base64-encoded cell BOC (Binary Object Code) (e.g., `te6ccgEBAQEAAgAAAA==`) +// - `slice_boc_hex`: Hex-encoded slice BOC (e.g., `b5ee9c72...`). +// Ref: #/components/schemas/ExecGetMethodArgType +type ExecGetMethodArgType string + +const ( + ExecGetMethodArgTypeNan ExecGetMethodArgType = "nan" + ExecGetMethodArgTypeNull ExecGetMethodArgType = "null" + ExecGetMethodArgTypeTinyint ExecGetMethodArgType = "tinyint" + ExecGetMethodArgTypeInt257 ExecGetMethodArgType = "int257" + ExecGetMethodArgTypeSlice ExecGetMethodArgType = "slice" + ExecGetMethodArgTypeCellBocBase64 ExecGetMethodArgType = "cell_boc_base64" + ExecGetMethodArgTypeSliceBocHex ExecGetMethodArgType = "slice_boc_hex" +) + +// AllValues returns all ExecGetMethodArgType values. +func (ExecGetMethodArgType) AllValues() []ExecGetMethodArgType { + return []ExecGetMethodArgType{ + ExecGetMethodArgTypeNan, + ExecGetMethodArgTypeNull, + ExecGetMethodArgTypeTinyint, + ExecGetMethodArgTypeInt257, + ExecGetMethodArgTypeSlice, + ExecGetMethodArgTypeCellBocBase64, + ExecGetMethodArgTypeSliceBocHex, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s ExecGetMethodArgType) MarshalText() ([]byte, error) { + switch s { + case ExecGetMethodArgTypeNan: + return []byte(s), nil + case ExecGetMethodArgTypeNull: + return []byte(s), nil + case ExecGetMethodArgTypeTinyint: + return []byte(s), nil + case ExecGetMethodArgTypeInt257: + return []byte(s), nil + case ExecGetMethodArgTypeSlice: + return []byte(s), nil + case ExecGetMethodArgTypeCellBocBase64: + return []byte(s), nil + case ExecGetMethodArgTypeSliceBocHex: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *ExecGetMethodArgType) UnmarshalText(data []byte) error { + switch ExecGetMethodArgType(data) { + case ExecGetMethodArgTypeNan: + *s = ExecGetMethodArgTypeNan + return nil + case ExecGetMethodArgTypeNull: + *s = ExecGetMethodArgTypeNull + return nil + case ExecGetMethodArgTypeTinyint: + *s = ExecGetMethodArgTypeTinyint + return nil + case ExecGetMethodArgTypeInt257: + *s = ExecGetMethodArgTypeInt257 + return nil + case ExecGetMethodArgTypeSlice: + *s = ExecGetMethodArgTypeSlice + return nil + case ExecGetMethodArgTypeCellBocBase64: + *s = ExecGetMethodArgTypeCellBocBase64 + return nil + case ExecGetMethodArgTypeSliceBocHex: + *s = ExecGetMethodArgTypeSliceBocHex + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + +type ExecGetMethodWithBodyForBlockchainAccountReq struct { + Args []ExecGetMethodArg `json:"args"` +} + +// GetArgs returns the value of Args. +func (s *ExecGetMethodWithBodyForBlockchainAccountReq) GetArgs() []ExecGetMethodArg { + return s.Args +} + +// SetArgs sets the value of Args. +func (s *ExecGetMethodWithBodyForBlockchainAccountReq) SetArgs(val []ExecGetMethodArg) { + s.Args = val +} + +// Ref: #/components/schemas/ExtraCurrency +type ExtraCurrency struct { + Amount string `json:"amount"` + Preview EcPreview `json:"preview"` +} + +// GetAmount returns the value of Amount. +func (s *ExtraCurrency) GetAmount() string { + return s.Amount +} + +// GetPreview returns the value of Preview. +func (s *ExtraCurrency) GetPreview() EcPreview { + return s.Preview +} + +// SetAmount sets the value of Amount. +func (s *ExtraCurrency) SetAmount(val string) { + s.Amount = val +} + +// SetPreview sets the value of Preview. +func (s *ExtraCurrency) SetPreview(val EcPreview) { + s.Preview = val +} + +// Ref: #/components/schemas/ExtraCurrencyTransferAction +type ExtraCurrencyTransferAction struct { + Sender AccountAddress `json:"sender"` + Recipient AccountAddress `json:"recipient"` + // Amount in quanta of tokens. + Amount string `json:"amount"` + Comment OptString `json:"comment"` + EncryptedComment OptEncryptedComment `json:"encrypted_comment"` + Currency EcPreview `json:"currency"` +} + +// GetSender returns the value of Sender. +func (s *ExtraCurrencyTransferAction) GetSender() AccountAddress { + return s.Sender +} + +// GetRecipient returns the value of Recipient. +func (s *ExtraCurrencyTransferAction) GetRecipient() AccountAddress { + return s.Recipient +} + +// GetAmount returns the value of Amount. +func (s *ExtraCurrencyTransferAction) GetAmount() string { + return s.Amount +} + +// GetComment returns the value of Comment. +func (s *ExtraCurrencyTransferAction) GetComment() OptString { + return s.Comment +} + +// GetEncryptedComment returns the value of EncryptedComment. +func (s *ExtraCurrencyTransferAction) GetEncryptedComment() OptEncryptedComment { + return s.EncryptedComment +} + +// GetCurrency returns the value of Currency. +func (s *ExtraCurrencyTransferAction) GetCurrency() EcPreview { + return s.Currency +} + +// SetSender sets the value of Sender. +func (s *ExtraCurrencyTransferAction) SetSender(val AccountAddress) { + s.Sender = val +} + +// SetRecipient sets the value of Recipient. +func (s *ExtraCurrencyTransferAction) SetRecipient(val AccountAddress) { + s.Recipient = val +} + +// SetAmount sets the value of Amount. +func (s *ExtraCurrencyTransferAction) SetAmount(val string) { + s.Amount = val +} + +// SetComment sets the value of Comment. +func (s *ExtraCurrencyTransferAction) SetComment(val OptString) { + s.Comment = val +} + +// SetEncryptedComment sets the value of EncryptedComment. +func (s *ExtraCurrencyTransferAction) SetEncryptedComment(val OptEncryptedComment) { + s.EncryptedComment = val +} + +// SetCurrency sets the value of Currency. +func (s *ExtraCurrencyTransferAction) SetCurrency(val EcPreview) { + s.Currency = val +} + // Ref: #/components/schemas/FoundAccounts type FoundAccounts struct { Addresses []FoundAccountsAddressesItem `json:"addresses"` @@ -5290,9 +6042,10 @@ func (s *FoundAccounts) SetAddresses(val []FoundAccountsAddressesItem) { } type FoundAccountsAddressesItem struct { - Address string `json:"address"` - Name string `json:"name"` - Preview string `json:"preview"` + Address string `json:"address"` + Name string `json:"name"` + Preview string `json:"preview"` + Trust TrustType `json:"trust"` } // GetAddress returns the value of Address. @@ -5310,6 +6063,11 @@ func (s *FoundAccountsAddressesItem) GetPreview() string { return s.Preview } +// GetTrust returns the value of Trust. +func (s *FoundAccountsAddressesItem) GetTrust() TrustType { + return s.Trust +} + // SetAddress sets the value of Address. func (s *FoundAccountsAddressesItem) SetAddress(val string) { s.Address = val @@ -5325,6 +6083,11 @@ func (s *FoundAccountsAddressesItem) SetPreview(val string) { s.Preview = val } +// SetTrust sets the value of Trust. +func (s *FoundAccountsAddressesItem) SetTrust(val TrustType) { + s.Trust = val +} + // Ref: #/components/schemas/GasLimitPrices type GasLimitPrices struct { SpecialGasLimit OptInt64 `json:"special_gas_limit"` @@ -5428,11 +6191,48 @@ func (s *GasLimitPrices) SetDeleteDueLimit(val int64) { s.DeleteDueLimit = val } -// Ref: #/components/schemas/GaslessConfig -type GaslessConfig struct { - // Sending excess to this address decreases the commission of a gasless transfer. - RelayAddress string `json:"relay_address"` - // List of jettons, any of them can be used to pay for gas. +// Ref: #/components/schemas/GasRelayAction +type GasRelayAction struct { + Amount int64 `json:"amount"` + Relayer AccountAddress `json:"relayer"` + Target AccountAddress `json:"target"` +} + +// GetAmount returns the value of Amount. +func (s *GasRelayAction) GetAmount() int64 { + return s.Amount +} + +// GetRelayer returns the value of Relayer. +func (s *GasRelayAction) GetRelayer() AccountAddress { + return s.Relayer +} + +// GetTarget returns the value of Target. +func (s *GasRelayAction) GetTarget() AccountAddress { + return s.Target +} + +// SetAmount sets the value of Amount. +func (s *GasRelayAction) SetAmount(val int64) { + s.Amount = val +} + +// SetRelayer sets the value of Relayer. +func (s *GasRelayAction) SetRelayer(val AccountAddress) { + s.Relayer = val +} + +// SetTarget sets the value of Target. +func (s *GasRelayAction) SetTarget(val AccountAddress) { + s.Target = val +} + +// Ref: #/components/schemas/GaslessConfig +type GaslessConfig struct { + // Sending excess to this address decreases the commission of a gasless transfer. + RelayAddress string `json:"relay_address"` + // List of jettons, any of them can be used to pay for gas. GasJettons []GaslessConfigGasJettonsItem `json:"gas_jettons"` } @@ -5471,9 +6271,22 @@ func (s *GaslessConfigGasJettonsItem) SetMasterID(val string) { } type GaslessEstimateReq struct { - WalletAddress string `json:"wallet_address"` - WalletPublicKey string `json:"wallet_public_key"` - Messages []GaslessEstimateReqMessagesItem `json:"messages"` + // TONAPI verifies that the account has enough jettons to pay the commission and make a transfer. + ThrowErrorIfNotEnoughJettons OptBool `json:"throw_error_if_not_enough_jettons"` + ReturnEmulation OptBool `json:"return_emulation"` + WalletAddress string `json:"wallet_address"` + WalletPublicKey string `json:"wallet_public_key"` + Messages []GaslessEstimateReqMessagesItem `json:"messages"` +} + +// GetThrowErrorIfNotEnoughJettons returns the value of ThrowErrorIfNotEnoughJettons. +func (s *GaslessEstimateReq) GetThrowErrorIfNotEnoughJettons() OptBool { + return s.ThrowErrorIfNotEnoughJettons +} + +// GetReturnEmulation returns the value of ReturnEmulation. +func (s *GaslessEstimateReq) GetReturnEmulation() OptBool { + return s.ReturnEmulation } // GetWalletAddress returns the value of WalletAddress. @@ -5491,6 +6304,16 @@ func (s *GaslessEstimateReq) GetMessages() []GaslessEstimateReqMessagesItem { return s.Messages } +// SetThrowErrorIfNotEnoughJettons sets the value of ThrowErrorIfNotEnoughJettons. +func (s *GaslessEstimateReq) SetThrowErrorIfNotEnoughJettons(val OptBool) { + s.ThrowErrorIfNotEnoughJettons = val +} + +// SetReturnEmulation sets the value of ReturnEmulation. +func (s *GaslessEstimateReq) SetReturnEmulation(val OptBool) { + s.ReturnEmulation = val +} + // SetWalletAddress sets the value of WalletAddress. func (s *GaslessEstimateReq) SetWalletAddress(val string) { s.WalletAddress = val @@ -5520,9 +6343,6 @@ func (s *GaslessEstimateReqMessagesItem) SetBoc(val string) { s.Boc = val } -// GaslessSendOK is response for GaslessSend operation. -type GaslessSendOK struct{} - type GaslessSendReq struct { // Hex encoded public key. WalletPublicKey string `json:"wallet_public_key"` @@ -5549,6 +6369,21 @@ func (s *GaslessSendReq) SetBoc(val string) { s.Boc = val } +// Ref: #/components/schemas/GaslessTx +type GaslessTx struct { + ProtocolName string `json:"protocol_name"` +} + +// GetProtocolName returns the value of ProtocolName. +func (s *GaslessTx) GetProtocolName() string { + return s.ProtocolName +} + +// SetProtocolName sets the value of ProtocolName. +func (s *GaslessTx) SetProtocolName(val string) { + s.ProtocolName = val +} + type GetAccountDiffOK struct { BalanceChange int64 `json:"balance_change"` } @@ -5684,117 +6519,31 @@ func (s *GetBlockchainAccountTransactionsSortOrder) UnmarshalText(data []byte) e } type GetChartRatesOK struct { - Points jx.Raw `json:"points"` + Points ChartPoints `json:"points"` } // GetPoints returns the value of Points. -func (s *GetChartRatesOK) GetPoints() jx.Raw { +func (s *GetChartRatesOK) GetPoints() ChartPoints { return s.Points } // SetPoints sets the value of Points. -func (s *GetChartRatesOK) SetPoints(val jx.Raw) { +func (s *GetChartRatesOK) SetPoints(val ChartPoints) { s.Points = val } -type GetInscriptionOpTemplateOK struct { - Comment string `json:"comment"` - Destination string `json:"destination"` -} - -// GetComment returns the value of Comment. -func (s *GetInscriptionOpTemplateOK) GetComment() string { - return s.Comment -} - -// GetDestination returns the value of Destination. -func (s *GetInscriptionOpTemplateOK) GetDestination() string { - return s.Destination -} - -// SetComment sets the value of Comment. -func (s *GetInscriptionOpTemplateOK) SetComment(val string) { - s.Comment = val -} - -// SetDestination sets the value of Destination. -func (s *GetInscriptionOpTemplateOK) SetDestination(val string) { - s.Destination = val -} - -type GetInscriptionOpTemplateOperation string - -const ( - GetInscriptionOpTemplateOperationTransfer GetInscriptionOpTemplateOperation = "transfer" -) - -// AllValues returns all GetInscriptionOpTemplateOperation values. -func (GetInscriptionOpTemplateOperation) AllValues() []GetInscriptionOpTemplateOperation { - return []GetInscriptionOpTemplateOperation{ - GetInscriptionOpTemplateOperationTransfer, - } -} - -// MarshalText implements encoding.TextMarshaler. -func (s GetInscriptionOpTemplateOperation) MarshalText() ([]byte, error) { - switch s { - case GetInscriptionOpTemplateOperationTransfer: - return []byte(s), nil - default: - return nil, errors.Errorf("invalid value: %q", s) - } -} - -// UnmarshalText implements encoding.TextUnmarshaler. -func (s *GetInscriptionOpTemplateOperation) UnmarshalText(data []byte) error { - switch GetInscriptionOpTemplateOperation(data) { - case GetInscriptionOpTemplateOperationTransfer: - *s = GetInscriptionOpTemplateOperationTransfer - return nil - default: - return errors.Errorf("invalid value: %q", data) - } -} - -type GetInscriptionOpTemplateType string - -const ( - GetInscriptionOpTemplateTypeTon20 GetInscriptionOpTemplateType = "ton20" - GetInscriptionOpTemplateTypeGram20 GetInscriptionOpTemplateType = "gram20" -) - -// AllValues returns all GetInscriptionOpTemplateType values. -func (GetInscriptionOpTemplateType) AllValues() []GetInscriptionOpTemplateType { - return []GetInscriptionOpTemplateType{ - GetInscriptionOpTemplateTypeTon20, - GetInscriptionOpTemplateTypeGram20, - } +type GetJettonInfosByAddressesReq struct { + AccountIds []string `json:"account_ids"` } -// MarshalText implements encoding.TextMarshaler. -func (s GetInscriptionOpTemplateType) MarshalText() ([]byte, error) { - switch s { - case GetInscriptionOpTemplateTypeTon20: - return []byte(s), nil - case GetInscriptionOpTemplateTypeGram20: - return []byte(s), nil - default: - return nil, errors.Errorf("invalid value: %q", s) - } +// GetAccountIds returns the value of AccountIds. +func (s *GetJettonInfosByAddressesReq) GetAccountIds() []string { + return s.AccountIds } -// UnmarshalText implements encoding.TextUnmarshaler. -func (s *GetInscriptionOpTemplateType) UnmarshalText(data []byte) error { - switch GetInscriptionOpTemplateType(data) { - case GetInscriptionOpTemplateTypeTon20: - *s = GetInscriptionOpTemplateTypeTon20 - return nil - case GetInscriptionOpTemplateTypeGram20: - *s = GetInscriptionOpTemplateTypeGram20 - return nil - default: - return errors.Errorf("invalid value: %q", data) - } +// SetAccountIds sets the value of AccountIds. +func (s *GetJettonInfosByAddressesReq) SetAccountIds(val []string) { + s.AccountIds = val } type GetMarketsRatesOK struct { @@ -5811,6 +6560,20 @@ func (s *GetMarketsRatesOK) SetMarkets(val []MarketTonRates) { s.Markets = val } +type GetNftCollectionItemsByAddressesReq struct { + AccountIds []string `json:"account_ids"` +} + +// GetAccountIds returns the value of AccountIds. +func (s *GetNftCollectionItemsByAddressesReq) GetAccountIds() []string { + return s.AccountIds +} + +// SetAccountIds sets the value of AccountIds. +func (s *GetNftCollectionItemsByAddressesReq) SetAccountIds(val []string) { + s.AccountIds = val +} + type GetNftItemsByAddressesReq struct { AccountIds []string `json:"account_ids"` } @@ -5825,6 +6588,20 @@ func (s *GetNftItemsByAddressesReq) SetAccountIds(val []string) { s.AccountIds = val } +type GetOpenapiYmlOK struct { + Data io.Reader +} + +// Read reads data from the Data reader. +// +// Kept to satisfy the io.Reader interface. +func (s GetOpenapiYmlOK) Read(p []byte) (n int, err error) { + if s.Data == nil { + return 0, io.EOF + } + return s.Data.Read(p) +} + type GetOutMsgQueueSizesOK struct { ExtMsgQueueSizeLimit uint32 `json:"ext_msg_queue_size_limit"` Shards []GetOutMsgQueueSizesOKShardsItem `json:"shards"` @@ -6855,20 +7632,6 @@ func (s *GetTonConnectPayloadOK) SetPayload(val string) { s.Payload = val } -type GetWalletBackupOK struct { - Dump string `json:"dump"` -} - -// GetDump returns the value of Dump. -func (s *GetWalletBackupOK) GetDump() string { - return s.Dump -} - -// SetDump sets the value of Dump. -func (s *GetWalletBackupOK) SetDump(val string) { - s.Dump = val -} - // Ref: #/components/schemas/ImagePreview type ImagePreview struct { Resolution string `json:"resolution"` @@ -6932,458 +7695,130 @@ func (s *InitStateRaw) SetFileHash(val string) { s.FileHash = val } -// Ref: #/components/schemas/InscriptionBalance -type InscriptionBalance struct { - Type InscriptionBalanceType `json:"type"` - Ticker string `json:"ticker"` - Balance string `json:"balance"` - Decimals int `json:"decimals"` -} - -// GetType returns the value of Type. -func (s *InscriptionBalance) GetType() InscriptionBalanceType { - return s.Type -} - -// GetTicker returns the value of Ticker. -func (s *InscriptionBalance) GetTicker() string { - return s.Ticker +// Ref: #/components/schemas/JettonBalance +type JettonBalance struct { + Balance string `json:"balance"` + Price OptTokenRates `json:"price"` + WalletAddress AccountAddress `json:"wallet_address"` + Jetton JettonPreview `json:"jetton"` + Extensions []string `json:"extensions"` + Lock OptJettonBalanceLock `json:"lock"` } // GetBalance returns the value of Balance. -func (s *InscriptionBalance) GetBalance() string { +func (s *JettonBalance) GetBalance() string { return s.Balance } -// GetDecimals returns the value of Decimals. -func (s *InscriptionBalance) GetDecimals() int { - return s.Decimals -} - -// SetType sets the value of Type. -func (s *InscriptionBalance) SetType(val InscriptionBalanceType) { - s.Type = val +// GetPrice returns the value of Price. +func (s *JettonBalance) GetPrice() OptTokenRates { + return s.Price } -// SetTicker sets the value of Ticker. -func (s *InscriptionBalance) SetTicker(val string) { - s.Ticker = val +// GetWalletAddress returns the value of WalletAddress. +func (s *JettonBalance) GetWalletAddress() AccountAddress { + return s.WalletAddress } -// SetBalance sets the value of Balance. -func (s *InscriptionBalance) SetBalance(val string) { - s.Balance = val +// GetJetton returns the value of Jetton. +func (s *JettonBalance) GetJetton() JettonPreview { + return s.Jetton } -// SetDecimals sets the value of Decimals. -func (s *InscriptionBalance) SetDecimals(val int) { - s.Decimals = val +// GetExtensions returns the value of Extensions. +func (s *JettonBalance) GetExtensions() []string { + return s.Extensions } -type InscriptionBalanceType string - -const ( - InscriptionBalanceTypeTon20 InscriptionBalanceType = "ton20" - InscriptionBalanceTypeGram20 InscriptionBalanceType = "gram20" -) - -// AllValues returns all InscriptionBalanceType values. -func (InscriptionBalanceType) AllValues() []InscriptionBalanceType { - return []InscriptionBalanceType{ - InscriptionBalanceTypeTon20, - InscriptionBalanceTypeGram20, - } +// GetLock returns the value of Lock. +func (s *JettonBalance) GetLock() OptJettonBalanceLock { + return s.Lock } -// MarshalText implements encoding.TextMarshaler. -func (s InscriptionBalanceType) MarshalText() ([]byte, error) { - switch s { - case InscriptionBalanceTypeTon20: - return []byte(s), nil - case InscriptionBalanceTypeGram20: - return []byte(s), nil - default: - return nil, errors.Errorf("invalid value: %q", s) - } +// SetBalance sets the value of Balance. +func (s *JettonBalance) SetBalance(val string) { + s.Balance = val } -// UnmarshalText implements encoding.TextUnmarshaler. -func (s *InscriptionBalanceType) UnmarshalText(data []byte) error { - switch InscriptionBalanceType(data) { - case InscriptionBalanceTypeTon20: - *s = InscriptionBalanceTypeTon20 - return nil - case InscriptionBalanceTypeGram20: - *s = InscriptionBalanceTypeGram20 - return nil - default: - return errors.Errorf("invalid value: %q", data) - } +// SetPrice sets the value of Price. +func (s *JettonBalance) SetPrice(val OptTokenRates) { + s.Price = val } -// Ref: #/components/schemas/InscriptionBalances -type InscriptionBalances struct { - Inscriptions []InscriptionBalance `json:"inscriptions"` +// SetWalletAddress sets the value of WalletAddress. +func (s *JettonBalance) SetWalletAddress(val AccountAddress) { + s.WalletAddress = val } -// GetInscriptions returns the value of Inscriptions. -func (s *InscriptionBalances) GetInscriptions() []InscriptionBalance { - return s.Inscriptions +// SetJetton sets the value of Jetton. +func (s *JettonBalance) SetJetton(val JettonPreview) { + s.Jetton = val } -// SetInscriptions sets the value of Inscriptions. -func (s *InscriptionBalances) SetInscriptions(val []InscriptionBalance) { - s.Inscriptions = val +// SetExtensions sets the value of Extensions. +func (s *JettonBalance) SetExtensions(val []string) { + s.Extensions = val } -// Ref: #/components/schemas/InscriptionMintAction -type InscriptionMintAction struct { - Recipient AccountAddress `json:"recipient"` - // Amount in minimal particles. - Amount string `json:"amount"` - Type InscriptionMintActionType `json:"type"` - Ticker string `json:"ticker"` - Decimals int `json:"decimals"` +// SetLock sets the value of Lock. +func (s *JettonBalance) SetLock(val OptJettonBalanceLock) { + s.Lock = val } -// GetRecipient returns the value of Recipient. -func (s *InscriptionMintAction) GetRecipient() AccountAddress { - return s.Recipient +type JettonBalanceLock struct { + Amount string `json:"amount"` + Till int64 `json:"till"` } // GetAmount returns the value of Amount. -func (s *InscriptionMintAction) GetAmount() string { +func (s *JettonBalanceLock) GetAmount() string { return s.Amount } -// GetType returns the value of Type. -func (s *InscriptionMintAction) GetType() InscriptionMintActionType { - return s.Type +// GetTill returns the value of Till. +func (s *JettonBalanceLock) GetTill() int64 { + return s.Till } -// GetTicker returns the value of Ticker. -func (s *InscriptionMintAction) GetTicker() string { - return s.Ticker +// SetAmount sets the value of Amount. +func (s *JettonBalanceLock) SetAmount(val string) { + s.Amount = val } -// GetDecimals returns the value of Decimals. -func (s *InscriptionMintAction) GetDecimals() int { - return s.Decimals +// SetTill sets the value of Till. +func (s *JettonBalanceLock) SetTill(val int64) { + s.Till = val } -// SetRecipient sets the value of Recipient. -func (s *InscriptionMintAction) SetRecipient(val AccountAddress) { - s.Recipient = val +// Ref: #/components/schemas/JettonBridgeParams +type JettonBridgeParams struct { + BridgeAddress string `json:"bridge_address"` + OraclesAddress string `json:"oracles_address"` + StateFlags int `json:"state_flags"` + BurnBridgeFee OptInt64 `json:"burn_bridge_fee"` + Oracles []Oracle `json:"oracles"` + ExternalChainAddress OptString `json:"external_chain_address"` + Prices OptJettonBridgePrices `json:"prices"` } -// SetAmount sets the value of Amount. -func (s *InscriptionMintAction) SetAmount(val string) { - s.Amount = val +// GetBridgeAddress returns the value of BridgeAddress. +func (s *JettonBridgeParams) GetBridgeAddress() string { + return s.BridgeAddress } -// SetType sets the value of Type. -func (s *InscriptionMintAction) SetType(val InscriptionMintActionType) { - s.Type = val +// GetOraclesAddress returns the value of OraclesAddress. +func (s *JettonBridgeParams) GetOraclesAddress() string { + return s.OraclesAddress } -// SetTicker sets the value of Ticker. -func (s *InscriptionMintAction) SetTicker(val string) { - s.Ticker = val +// GetStateFlags returns the value of StateFlags. +func (s *JettonBridgeParams) GetStateFlags() int { + return s.StateFlags } -// SetDecimals sets the value of Decimals. -func (s *InscriptionMintAction) SetDecimals(val int) { - s.Decimals = val -} - -type InscriptionMintActionType string - -const ( - InscriptionMintActionTypeTon20 InscriptionMintActionType = "ton20" - InscriptionMintActionTypeGram20 InscriptionMintActionType = "gram20" -) - -// AllValues returns all InscriptionMintActionType values. -func (InscriptionMintActionType) AllValues() []InscriptionMintActionType { - return []InscriptionMintActionType{ - InscriptionMintActionTypeTon20, - InscriptionMintActionTypeGram20, - } -} - -// MarshalText implements encoding.TextMarshaler. -func (s InscriptionMintActionType) MarshalText() ([]byte, error) { - switch s { - case InscriptionMintActionTypeTon20: - return []byte(s), nil - case InscriptionMintActionTypeGram20: - return []byte(s), nil - default: - return nil, errors.Errorf("invalid value: %q", s) - } -} - -// UnmarshalText implements encoding.TextUnmarshaler. -func (s *InscriptionMintActionType) UnmarshalText(data []byte) error { - switch InscriptionMintActionType(data) { - case InscriptionMintActionTypeTon20: - *s = InscriptionMintActionTypeTon20 - return nil - case InscriptionMintActionTypeGram20: - *s = InscriptionMintActionTypeGram20 - return nil - default: - return errors.Errorf("invalid value: %q", data) - } -} - -// Ref: #/components/schemas/InscriptionTransferAction -type InscriptionTransferAction struct { - Sender AccountAddress `json:"sender"` - Recipient AccountAddress `json:"recipient"` - // Amount in minimal particles. - Amount string `json:"amount"` - Comment OptString `json:"comment"` - Type InscriptionTransferActionType `json:"type"` - Ticker string `json:"ticker"` - Decimals int `json:"decimals"` -} - -// GetSender returns the value of Sender. -func (s *InscriptionTransferAction) GetSender() AccountAddress { - return s.Sender -} - -// GetRecipient returns the value of Recipient. -func (s *InscriptionTransferAction) GetRecipient() AccountAddress { - return s.Recipient -} - -// GetAmount returns the value of Amount. -func (s *InscriptionTransferAction) GetAmount() string { - return s.Amount -} - -// GetComment returns the value of Comment. -func (s *InscriptionTransferAction) GetComment() OptString { - return s.Comment -} - -// GetType returns the value of Type. -func (s *InscriptionTransferAction) GetType() InscriptionTransferActionType { - return s.Type -} - -// GetTicker returns the value of Ticker. -func (s *InscriptionTransferAction) GetTicker() string { - return s.Ticker -} - -// GetDecimals returns the value of Decimals. -func (s *InscriptionTransferAction) GetDecimals() int { - return s.Decimals -} - -// SetSender sets the value of Sender. -func (s *InscriptionTransferAction) SetSender(val AccountAddress) { - s.Sender = val -} - -// SetRecipient sets the value of Recipient. -func (s *InscriptionTransferAction) SetRecipient(val AccountAddress) { - s.Recipient = val -} - -// SetAmount sets the value of Amount. -func (s *InscriptionTransferAction) SetAmount(val string) { - s.Amount = val -} - -// SetComment sets the value of Comment. -func (s *InscriptionTransferAction) SetComment(val OptString) { - s.Comment = val -} - -// SetType sets the value of Type. -func (s *InscriptionTransferAction) SetType(val InscriptionTransferActionType) { - s.Type = val -} - -// SetTicker sets the value of Ticker. -func (s *InscriptionTransferAction) SetTicker(val string) { - s.Ticker = val -} - -// SetDecimals sets the value of Decimals. -func (s *InscriptionTransferAction) SetDecimals(val int) { - s.Decimals = val -} - -type InscriptionTransferActionType string - -const ( - InscriptionTransferActionTypeTon20 InscriptionTransferActionType = "ton20" - InscriptionTransferActionTypeGram20 InscriptionTransferActionType = "gram20" -) - -// AllValues returns all InscriptionTransferActionType values. -func (InscriptionTransferActionType) AllValues() []InscriptionTransferActionType { - return []InscriptionTransferActionType{ - InscriptionTransferActionTypeTon20, - InscriptionTransferActionTypeGram20, - } -} - -// MarshalText implements encoding.TextMarshaler. -func (s InscriptionTransferActionType) MarshalText() ([]byte, error) { - switch s { - case InscriptionTransferActionTypeTon20: - return []byte(s), nil - case InscriptionTransferActionTypeGram20: - return []byte(s), nil - default: - return nil, errors.Errorf("invalid value: %q", s) - } -} - -// UnmarshalText implements encoding.TextUnmarshaler. -func (s *InscriptionTransferActionType) UnmarshalText(data []byte) error { - switch InscriptionTransferActionType(data) { - case InscriptionTransferActionTypeTon20: - *s = InscriptionTransferActionTypeTon20 - return nil - case InscriptionTransferActionTypeGram20: - *s = InscriptionTransferActionTypeGram20 - return nil - default: - return errors.Errorf("invalid value: %q", data) - } -} - -// Ref: #/components/schemas/JettonBalance -type JettonBalance struct { - Balance string `json:"balance"` - Price OptTokenRates `json:"price"` - WalletAddress AccountAddress `json:"wallet_address"` - Jetton JettonPreview `json:"jetton"` - Extensions []string `json:"extensions"` - Lock OptJettonBalanceLock `json:"lock"` -} - -// GetBalance returns the value of Balance. -func (s *JettonBalance) GetBalance() string { - return s.Balance -} - -// GetPrice returns the value of Price. -func (s *JettonBalance) GetPrice() OptTokenRates { - return s.Price -} - -// GetWalletAddress returns the value of WalletAddress. -func (s *JettonBalance) GetWalletAddress() AccountAddress { - return s.WalletAddress -} - -// GetJetton returns the value of Jetton. -func (s *JettonBalance) GetJetton() JettonPreview { - return s.Jetton -} - -// GetExtensions returns the value of Extensions. -func (s *JettonBalance) GetExtensions() []string { - return s.Extensions -} - -// GetLock returns the value of Lock. -func (s *JettonBalance) GetLock() OptJettonBalanceLock { - return s.Lock -} - -// SetBalance sets the value of Balance. -func (s *JettonBalance) SetBalance(val string) { - s.Balance = val -} - -// SetPrice sets the value of Price. -func (s *JettonBalance) SetPrice(val OptTokenRates) { - s.Price = val -} - -// SetWalletAddress sets the value of WalletAddress. -func (s *JettonBalance) SetWalletAddress(val AccountAddress) { - s.WalletAddress = val -} - -// SetJetton sets the value of Jetton. -func (s *JettonBalance) SetJetton(val JettonPreview) { - s.Jetton = val -} - -// SetExtensions sets the value of Extensions. -func (s *JettonBalance) SetExtensions(val []string) { - s.Extensions = val -} - -// SetLock sets the value of Lock. -func (s *JettonBalance) SetLock(val OptJettonBalanceLock) { - s.Lock = val -} - -type JettonBalanceLock struct { - Amount string `json:"amount"` - Till int64 `json:"till"` -} - -// GetAmount returns the value of Amount. -func (s *JettonBalanceLock) GetAmount() string { - return s.Amount -} - -// GetTill returns the value of Till. -func (s *JettonBalanceLock) GetTill() int64 { - return s.Till -} - -// SetAmount sets the value of Amount. -func (s *JettonBalanceLock) SetAmount(val string) { - s.Amount = val -} - -// SetTill sets the value of Till. -func (s *JettonBalanceLock) SetTill(val int64) { - s.Till = val -} - -// Ref: #/components/schemas/JettonBridgeParams -type JettonBridgeParams struct { - BridgeAddress string `json:"bridge_address"` - OraclesAddress string `json:"oracles_address"` - StateFlags int `json:"state_flags"` - BurnBridgeFee OptInt64 `json:"burn_bridge_fee"` - Oracles []Oracle `json:"oracles"` - ExternalChainAddress OptString `json:"external_chain_address"` - Prices OptJettonBridgePrices `json:"prices"` -} - -// GetBridgeAddress returns the value of BridgeAddress. -func (s *JettonBridgeParams) GetBridgeAddress() string { - return s.BridgeAddress -} - -// GetOraclesAddress returns the value of OraclesAddress. -func (s *JettonBridgeParams) GetOraclesAddress() string { - return s.OraclesAddress -} - -// GetStateFlags returns the value of StateFlags. -func (s *JettonBridgeParams) GetStateFlags() int { - return s.StateFlags -} - -// GetBurnBridgeFee returns the value of BurnBridgeFee. -func (s *JettonBridgeParams) GetBurnBridgeFee() OptInt64 { - return s.BurnBridgeFee +// GetBurnBridgeFee returns the value of BurnBridgeFee. +func (s *JettonBridgeParams) GetBurnBridgeFee() OptInt64 { + return s.BurnBridgeFee } // GetOracles returns the value of Oracles. @@ -7625,6 +8060,7 @@ type JettonInfo struct { TotalSupply string `json:"total_supply"` Admin OptAccountAddress `json:"admin"` Metadata JettonMetadata `json:"metadata"` + Preview string `json:"preview"` Verification JettonVerificationType `json:"verification"` HoldersCount int32 `json:"holders_count"` } @@ -7649,6 +8085,11 @@ func (s *JettonInfo) GetMetadata() JettonMetadata { return s.Metadata } +// GetPreview returns the value of Preview. +func (s *JettonInfo) GetPreview() string { + return s.Preview +} + // GetVerification returns the value of Verification. func (s *JettonInfo) GetVerification() JettonVerificationType { return s.Verification @@ -7679,6 +8120,11 @@ func (s *JettonInfo) SetMetadata(val JettonMetadata) { s.Metadata = val } +// SetPreview sets the value of Preview. +func (s *JettonInfo) SetPreview(val string) { + s.Preview = val +} + // SetVerification sets the value of Verification. func (s *JettonInfo) SetVerification(val JettonVerificationType) { s.Verification = val @@ -7691,15 +8137,19 @@ func (s *JettonInfo) SetHoldersCount(val int32) { // Ref: #/components/schemas/JettonMetadata type JettonMetadata struct { - Address string `json:"address"` - Name string `json:"name"` - Symbol string `json:"symbol"` - Decimals string `json:"decimals"` - Image OptString `json:"image"` - Description OptString `json:"description"` - Social []string `json:"social"` - Websites []string `json:"websites"` - Catalogs []string `json:"catalogs"` + Address string `json:"address"` + Name string `json:"name"` + Symbol string `json:"symbol"` + Decimals string `json:"decimals"` + // This field currently returns a cached image URL (e.g., "https://cache.tonapi.io/images/jetton. + // jpg"). In the future, this will be replaced with the original URL from the metadata. The cached + // image is already available in the `preview` field of `JettonInfo` and will remain there. + Image OptString `json:"image"` + Description OptString `json:"description"` + Social []string `json:"social"` + Websites []string `json:"websites"` + Catalogs []string `json:"catalogs"` + CustomPayloadAPIURI OptString `json:"custom_payload_api_uri"` } // GetAddress returns the value of Address. @@ -7747,6 +8197,11 @@ func (s *JettonMetadata) GetCatalogs() []string { return s.Catalogs } +// GetCustomPayloadAPIURI returns the value of CustomPayloadAPIURI. +func (s *JettonMetadata) GetCustomPayloadAPIURI() OptString { + return s.CustomPayloadAPIURI +} + // SetAddress sets the value of Address. func (s *JettonMetadata) SetAddress(val string) { s.Address = val @@ -7792,6 +8247,11 @@ func (s *JettonMetadata) SetCatalogs(val []string) { s.Catalogs = val } +// SetCustomPayloadAPIURI sets the value of CustomPayloadAPIURI. +func (s *JettonMetadata) SetCustomPayloadAPIURI(val OptString) { + s.CustomPayloadAPIURI = val +} + // Ref: #/components/schemas/JettonMintAction type JettonMintAction struct { Recipient AccountAddress `json:"recipient"` @@ -7841,14 +8301,215 @@ func (s *JettonMintAction) SetJetton(val JettonPreview) { s.Jetton = val } +// Ref: #/components/schemas/JettonOperation +type JettonOperation struct { + Operation JettonOperationOperation `json:"operation"` + Utime int64 `json:"utime"` + Lt int64 `json:"lt"` + TransactionHash string `json:"transaction_hash"` + Source OptAccountAddress `json:"source"` + Destination OptAccountAddress `json:"destination"` + Amount string `json:"amount"` + Jetton JettonPreview `json:"jetton"` + TraceID string `json:"trace_id"` + QueryID string `json:"query_id"` + Payload jx.Raw `json:"payload"` +} + +// GetOperation returns the value of Operation. +func (s *JettonOperation) GetOperation() JettonOperationOperation { + return s.Operation +} + +// GetUtime returns the value of Utime. +func (s *JettonOperation) GetUtime() int64 { + return s.Utime +} + +// GetLt returns the value of Lt. +func (s *JettonOperation) GetLt() int64 { + return s.Lt +} + +// GetTransactionHash returns the value of TransactionHash. +func (s *JettonOperation) GetTransactionHash() string { + return s.TransactionHash +} + +// GetSource returns the value of Source. +func (s *JettonOperation) GetSource() OptAccountAddress { + return s.Source +} + +// GetDestination returns the value of Destination. +func (s *JettonOperation) GetDestination() OptAccountAddress { + return s.Destination +} + +// GetAmount returns the value of Amount. +func (s *JettonOperation) GetAmount() string { + return s.Amount +} + +// GetJetton returns the value of Jetton. +func (s *JettonOperation) GetJetton() JettonPreview { + return s.Jetton +} + +// GetTraceID returns the value of TraceID. +func (s *JettonOperation) GetTraceID() string { + return s.TraceID +} + +// GetQueryID returns the value of QueryID. +func (s *JettonOperation) GetQueryID() string { + return s.QueryID +} + +// GetPayload returns the value of Payload. +func (s *JettonOperation) GetPayload() jx.Raw { + return s.Payload +} + +// SetOperation sets the value of Operation. +func (s *JettonOperation) SetOperation(val JettonOperationOperation) { + s.Operation = val +} + +// SetUtime sets the value of Utime. +func (s *JettonOperation) SetUtime(val int64) { + s.Utime = val +} + +// SetLt sets the value of Lt. +func (s *JettonOperation) SetLt(val int64) { + s.Lt = val +} + +// SetTransactionHash sets the value of TransactionHash. +func (s *JettonOperation) SetTransactionHash(val string) { + s.TransactionHash = val +} + +// SetSource sets the value of Source. +func (s *JettonOperation) SetSource(val OptAccountAddress) { + s.Source = val +} + +// SetDestination sets the value of Destination. +func (s *JettonOperation) SetDestination(val OptAccountAddress) { + s.Destination = val +} + +// SetAmount sets the value of Amount. +func (s *JettonOperation) SetAmount(val string) { + s.Amount = val +} + +// SetJetton sets the value of Jetton. +func (s *JettonOperation) SetJetton(val JettonPreview) { + s.Jetton = val +} + +// SetTraceID sets the value of TraceID. +func (s *JettonOperation) SetTraceID(val string) { + s.TraceID = val +} + +// SetQueryID sets the value of QueryID. +func (s *JettonOperation) SetQueryID(val string) { + s.QueryID = val +} + +// SetPayload sets the value of Payload. +func (s *JettonOperation) SetPayload(val jx.Raw) { + s.Payload = val +} + +type JettonOperationOperation string + +const ( + JettonOperationOperationTransfer JettonOperationOperation = "transfer" + JettonOperationOperationMint JettonOperationOperation = "mint" + JettonOperationOperationBurn JettonOperationOperation = "burn" +) + +// AllValues returns all JettonOperationOperation values. +func (JettonOperationOperation) AllValues() []JettonOperationOperation { + return []JettonOperationOperation{ + JettonOperationOperationTransfer, + JettonOperationOperationMint, + JettonOperationOperationBurn, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s JettonOperationOperation) MarshalText() ([]byte, error) { + switch s { + case JettonOperationOperationTransfer: + return []byte(s), nil + case JettonOperationOperationMint: + return []byte(s), nil + case JettonOperationOperationBurn: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *JettonOperationOperation) UnmarshalText(data []byte) error { + switch JettonOperationOperation(data) { + case JettonOperationOperationTransfer: + *s = JettonOperationOperationTransfer + return nil + case JettonOperationOperationMint: + *s = JettonOperationOperationMint + return nil + case JettonOperationOperationBurn: + *s = JettonOperationOperationBurn + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + +// Ref: #/components/schemas/JettonOperations +type JettonOperations struct { + Operations []JettonOperation `json:"operations"` + NextFrom OptInt64 `json:"next_from"` +} + +// GetOperations returns the value of Operations. +func (s *JettonOperations) GetOperations() []JettonOperation { + return s.Operations +} + +// GetNextFrom returns the value of NextFrom. +func (s *JettonOperations) GetNextFrom() OptInt64 { + return s.NextFrom +} + +// SetOperations sets the value of Operations. +func (s *JettonOperations) SetOperations(val []JettonOperation) { + s.Operations = val +} + +// SetNextFrom sets the value of NextFrom. +func (s *JettonOperations) SetNextFrom(val OptInt64) { + s.NextFrom = val +} + // Ref: #/components/schemas/JettonPreview type JettonPreview struct { - Address string `json:"address"` - Name string `json:"name"` - Symbol string `json:"symbol"` - Decimals int `json:"decimals"` - Image string `json:"image"` - Verification JettonVerificationType `json:"verification"` + Address string `json:"address"` + Name string `json:"name"` + Symbol string `json:"symbol"` + Decimals int `json:"decimals"` + Image string `json:"image"` + Verification JettonVerificationType `json:"verification"` + CustomPayloadAPIURI OptString `json:"custom_payload_api_uri"` + Score int32 `json:"score"` } // GetAddress returns the value of Address. @@ -7881,6 +8542,16 @@ func (s *JettonPreview) GetVerification() JettonVerificationType { return s.Verification } +// GetCustomPayloadAPIURI returns the value of CustomPayloadAPIURI. +func (s *JettonPreview) GetCustomPayloadAPIURI() OptString { + return s.CustomPayloadAPIURI +} + +// GetScore returns the value of Score. +func (s *JettonPreview) GetScore() int32 { + return s.Score +} + // SetAddress sets the value of Address. func (s *JettonPreview) SetAddress(val string) { s.Address = val @@ -7911,6 +8582,16 @@ func (s *JettonPreview) SetVerification(val JettonVerificationType) { s.Verification = val } +// SetCustomPayloadAPIURI sets the value of CustomPayloadAPIURI. +func (s *JettonPreview) SetCustomPayloadAPIURI(val OptString) { + s.CustomPayloadAPIURI = val +} + +// SetScore sets the value of Score. +func (s *JettonPreview) SetScore(val int32) { + s.Score = val +} + // Ref: #/components/schemas/JettonQuantity type JettonQuantity struct { Quantity string `json:"quantity"` @@ -7950,19 +8631,19 @@ func (s *JettonQuantity) SetJetton(val JettonPreview) { // Ref: #/components/schemas/JettonSwapAction type JettonSwapAction struct { - Dex JettonSwapActionDex `json:"dex"` - AmountIn string `json:"amount_in"` - AmountOut string `json:"amount_out"` - TonIn OptInt64 `json:"ton_in"` - TonOut OptInt64 `json:"ton_out"` - UserWallet AccountAddress `json:"user_wallet"` - Router AccountAddress `json:"router"` - JettonMasterIn OptJettonPreview `json:"jetton_master_in"` - JettonMasterOut OptJettonPreview `json:"jetton_master_out"` + Dex string `json:"dex"` + AmountIn string `json:"amount_in"` + AmountOut string `json:"amount_out"` + TonIn OptInt64 `json:"ton_in"` + TonOut OptInt64 `json:"ton_out"` + UserWallet AccountAddress `json:"user_wallet"` + Router AccountAddress `json:"router"` + JettonMasterIn OptJettonPreview `json:"jetton_master_in"` + JettonMasterOut OptJettonPreview `json:"jetton_master_out"` } // GetDex returns the value of Dex. -func (s *JettonSwapAction) GetDex() JettonSwapActionDex { +func (s *JettonSwapAction) GetDex() string { return s.Dex } @@ -8007,7 +8688,7 @@ func (s *JettonSwapAction) GetJettonMasterOut() OptJettonPreview { } // SetDex sets the value of Dex. -func (s *JettonSwapAction) SetDex(val JettonSwapActionDex) { +func (s *JettonSwapAction) SetDex(val string) { s.Dex = val } @@ -8051,54 +8732,6 @@ func (s *JettonSwapAction) SetJettonMasterOut(val OptJettonPreview) { s.JettonMasterOut = val } -type JettonSwapActionDex string - -const ( - JettonSwapActionDexStonfi JettonSwapActionDex = "stonfi" - JettonSwapActionDexDedust JettonSwapActionDex = "dedust" - JettonSwapActionDexMegatonfi JettonSwapActionDex = "megatonfi" -) - -// AllValues returns all JettonSwapActionDex values. -func (JettonSwapActionDex) AllValues() []JettonSwapActionDex { - return []JettonSwapActionDex{ - JettonSwapActionDexStonfi, - JettonSwapActionDexDedust, - JettonSwapActionDexMegatonfi, - } -} - -// MarshalText implements encoding.TextMarshaler. -func (s JettonSwapActionDex) MarshalText() ([]byte, error) { - switch s { - case JettonSwapActionDexStonfi: - return []byte(s), nil - case JettonSwapActionDexDedust: - return []byte(s), nil - case JettonSwapActionDexMegatonfi: - return []byte(s), nil - default: - return nil, errors.Errorf("invalid value: %q", s) - } -} - -// UnmarshalText implements encoding.TextUnmarshaler. -func (s *JettonSwapActionDex) UnmarshalText(data []byte) error { - switch JettonSwapActionDex(data) { - case JettonSwapActionDexStonfi: - *s = JettonSwapActionDexStonfi - return nil - case JettonSwapActionDexDedust: - *s = JettonSwapActionDexDedust - return nil - case JettonSwapActionDexMegatonfi: - *s = JettonSwapActionDexMegatonfi - return nil - default: - return errors.Errorf("invalid value: %q", data) - } -} - // Ref: #/components/schemas/JettonTransferAction type JettonTransferAction struct { Sender OptAccountAddress `json:"sender"` @@ -8236,6 +8869,7 @@ type JettonVerificationType string const ( JettonVerificationTypeWhitelist JettonVerificationType = "whitelist" + JettonVerificationTypeGraylist JettonVerificationType = "graylist" JettonVerificationTypeBlacklist JettonVerificationType = "blacklist" JettonVerificationTypeNone JettonVerificationType = "none" ) @@ -8244,6 +8878,7 @@ const ( func (JettonVerificationType) AllValues() []JettonVerificationType { return []JettonVerificationType{ JettonVerificationTypeWhitelist, + JettonVerificationTypeGraylist, JettonVerificationTypeBlacklist, JettonVerificationTypeNone, } @@ -8254,6 +8889,8 @@ func (s JettonVerificationType) MarshalText() ([]byte, error) { switch s { case JettonVerificationTypeWhitelist: return []byte(s), nil + case JettonVerificationTypeGraylist: + return []byte(s), nil case JettonVerificationTypeBlacklist: return []byte(s), nil case JettonVerificationTypeNone: @@ -8269,6 +8906,9 @@ func (s *JettonVerificationType) UnmarshalText(data []byte) error { case JettonVerificationTypeWhitelist: *s = JettonVerificationTypeWhitelist return nil + case JettonVerificationTypeGraylist: + *s = JettonVerificationTypeGraylist + return nil case JettonVerificationTypeBlacklist: *s = JettonVerificationTypeBlacklist return nil @@ -8310,6 +8950,43 @@ func (s *JettonsBalances) SetBalances(val []JettonBalance) { s.Balances = val } +// Ref: #/components/schemas/LiquidityDepositAction +type LiquidityDepositAction struct { + Protocol Protocol `json:"protocol"` + From AccountAddress `json:"from"` + Tokens []VaultDepositInfo `json:"tokens"` +} + +// GetProtocol returns the value of Protocol. +func (s *LiquidityDepositAction) GetProtocol() Protocol { + return s.Protocol +} + +// GetFrom returns the value of From. +func (s *LiquidityDepositAction) GetFrom() AccountAddress { + return s.From +} + +// GetTokens returns the value of Tokens. +func (s *LiquidityDepositAction) GetTokens() []VaultDepositInfo { + return s.Tokens +} + +// SetProtocol sets the value of Protocol. +func (s *LiquidityDepositAction) SetProtocol(val Protocol) { + s.Protocol = val +} + +// SetFrom sets the value of From. +func (s *LiquidityDepositAction) SetFrom(val AccountAddress) { + s.From = val +} + +// SetTokens sets the value of Tokens. +func (s *LiquidityDepositAction) SetTokens(val []VaultDepositInfo) { + s.Tokens = val +} + // Ref: #/components/schemas/MarketTonRates type MarketTonRates struct { Market string `json:"market"` @@ -8355,6 +9032,7 @@ type Message struct { Bounce bool `json:"bounce"` Bounced bool `json:"bounced"` Value int64 `json:"value"` + ValueExtra []ExtraCurrency `json:"value_extra"` FwdFee int64 `json:"fwd_fee"` IhrFee int64 `json:"ihr_fee"` Destination OptAccountAddress `json:"destination"` @@ -8400,6 +9078,11 @@ func (s *Message) GetValue() int64 { return s.Value } +// GetValueExtra returns the value of ValueExtra. +func (s *Message) GetValueExtra() []ExtraCurrency { + return s.ValueExtra +} + // GetFwdFee returns the value of FwdFee. func (s *Message) GetFwdFee() int64 { return s.FwdFee @@ -8490,6 +9173,11 @@ func (s *Message) SetValue(val int64) { s.Value = val } +// SetValueExtra sets the value of ValueExtra. +func (s *Message) SetValueExtra(val []ExtraCurrency) { + s.ValueExtra = val +} + // SetFwdFee sets the value of FwdFee. func (s *Message) SetFwdFee(val int64) { s.FwdFee = val @@ -8635,6 +9323,60 @@ func (s *MessageMsgType) UnmarshalText(data []byte) error { } } +// Ref: #/components/schemas/Metadata +type Metadata struct { + // Hex encoded bytes. + EncryptedBinary string `json:"encrypted_binary"` + // Hex encoded bytes. + DecryptionKey OptString `json:"decryption_key"` +} + +// GetEncryptedBinary returns the value of EncryptedBinary. +func (s *Metadata) GetEncryptedBinary() string { + return s.EncryptedBinary +} + +// GetDecryptionKey returns the value of DecryptionKey. +func (s *Metadata) GetDecryptionKey() OptString { + return s.DecryptionKey +} + +// SetEncryptedBinary sets the value of EncryptedBinary. +func (s *Metadata) SetEncryptedBinary(val string) { + s.EncryptedBinary = val +} + +// SetDecryptionKey sets the value of DecryptionKey. +func (s *Metadata) SetDecryptionKey(val OptString) { + s.DecryptionKey = val +} + +// Ref: #/components/schemas/Method +type Method struct { + ID int64 `json:"id"` + Method string `json:"method"` +} + +// GetID returns the value of ID. +func (s *Method) GetID() int64 { + return s.ID +} + +// GetMethod returns the value of Method. +func (s *Method) GetMethod() string { + return s.Method +} + +// SetID sets the value of ID. +func (s *Method) SetID(val int64) { + s.ID = val +} + +// SetMethod sets the value of Method. +func (s *Method) SetMethod(val string) { + s.Method = val +} + // Ref: #/components/schemas/MethodExecutionResult type MethodExecutionResult struct { Success bool `json:"success"` @@ -8882,7 +9624,7 @@ func (s *MsgForwardPrices) SetNextFrac(val int64) { // Ref: #/components/schemas/Multisig type Multisig struct { Address string `json:"address"` - Seqno int64 `json:"seqno"` + Seqno string `json:"seqno"` Threshold int32 `json:"threshold"` Signers []string `json:"signers"` Proposers []string `json:"proposers"` @@ -8895,7 +9637,7 @@ func (s *Multisig) GetAddress() string { } // GetSeqno returns the value of Seqno. -func (s *Multisig) GetSeqno() int64 { +func (s *Multisig) GetSeqno() string { return s.Seqno } @@ -8925,7 +9667,7 @@ func (s *Multisig) SetAddress(val string) { } // SetSeqno sets the value of Seqno. -func (s *Multisig) SetSeqno(val int64) { +func (s *Multisig) SetSeqno(val string) { s.Seqno = val } @@ -8951,14 +9693,18 @@ func (s *Multisig) SetOrders(val []MultisigOrder) { // Ref: #/components/schemas/MultisigOrder type MultisigOrder struct { - Address string `json:"address"` - OrderSeqno int64 `json:"order_seqno"` - Threshold int32 `json:"threshold"` - SentForExecution bool `json:"sent_for_execution"` - Signers []string `json:"signers"` - ApprovalsNum int32 `json:"approvals_num"` - ExpirationDate int64 `json:"expiration_date"` - Risk Risk `json:"risk"` + Address string `json:"address"` + OrderSeqno string `json:"order_seqno"` + Threshold int32 `json:"threshold"` + SentForExecution bool `json:"sent_for_execution"` + Signers []string `json:"signers"` + ApprovalsNum int32 `json:"approvals_num"` + ExpirationDate int64 `json:"expiration_date"` + Risk Risk `json:"risk"` + CreationDate int64 `json:"creation_date"` + SignedBy []string `json:"signed_by"` + MultisigAddress string `json:"multisig_address"` + ChangingParameters OptMultisigOrderChangingParameters `json:"changing_parameters"` } // GetAddress returns the value of Address. @@ -8967,7 +9713,7 @@ func (s *MultisigOrder) GetAddress() string { } // GetOrderSeqno returns the value of OrderSeqno. -func (s *MultisigOrder) GetOrderSeqno() int64 { +func (s *MultisigOrder) GetOrderSeqno() string { return s.OrderSeqno } @@ -9001,13 +9747,33 @@ func (s *MultisigOrder) GetRisk() Risk { return s.Risk } +// GetCreationDate returns the value of CreationDate. +func (s *MultisigOrder) GetCreationDate() int64 { + return s.CreationDate +} + +// GetSignedBy returns the value of SignedBy. +func (s *MultisigOrder) GetSignedBy() []string { + return s.SignedBy +} + +// GetMultisigAddress returns the value of MultisigAddress. +func (s *MultisigOrder) GetMultisigAddress() string { + return s.MultisigAddress +} + +// GetChangingParameters returns the value of ChangingParameters. +func (s *MultisigOrder) GetChangingParameters() OptMultisigOrderChangingParameters { + return s.ChangingParameters +} + // SetAddress sets the value of Address. func (s *MultisigOrder) SetAddress(val string) { s.Address = val } // SetOrderSeqno sets the value of OrderSeqno. -func (s *MultisigOrder) SetOrderSeqno(val int64) { +func (s *MultisigOrder) SetOrderSeqno(val string) { s.OrderSeqno = val } @@ -9041,6 +9807,62 @@ func (s *MultisigOrder) SetRisk(val Risk) { s.Risk = val } +// SetCreationDate sets the value of CreationDate. +func (s *MultisigOrder) SetCreationDate(val int64) { + s.CreationDate = val +} + +// SetSignedBy sets the value of SignedBy. +func (s *MultisigOrder) SetSignedBy(val []string) { + s.SignedBy = val +} + +// SetMultisigAddress sets the value of MultisigAddress. +func (s *MultisigOrder) SetMultisigAddress(val string) { + s.MultisigAddress = val +} + +// SetChangingParameters sets the value of ChangingParameters. +func (s *MultisigOrder) SetChangingParameters(val OptMultisigOrderChangingParameters) { + s.ChangingParameters = val +} + +type MultisigOrderChangingParameters struct { + Threshold int32 `json:"threshold"` + Signers []string `json:"signers"` + Proposers []string `json:"proposers"` +} + +// GetThreshold returns the value of Threshold. +func (s *MultisigOrderChangingParameters) GetThreshold() int32 { + return s.Threshold +} + +// GetSigners returns the value of Signers. +func (s *MultisigOrderChangingParameters) GetSigners() []string { + return s.Signers +} + +// GetProposers returns the value of Proposers. +func (s *MultisigOrderChangingParameters) GetProposers() []string { + return s.Proposers +} + +// SetThreshold sets the value of Threshold. +func (s *MultisigOrderChangingParameters) SetThreshold(val int32) { + s.Threshold = val +} + +// SetSigners sets the value of Signers. +func (s *MultisigOrderChangingParameters) SetSigners(val []string) { + s.Signers = val +} + +// SetProposers sets the value of Proposers. +func (s *MultisigOrderChangingParameters) SetProposers(val []string) { + s.Proposers = val +} + // Ref: #/components/schemas/Multisigs type Multisigs struct { Multisigs []Multisig `json:"multisigs"` @@ -9061,9 +9883,8 @@ type NftApprovedBy []NftApprovedByItem type NftApprovedByItem string const ( - NftApprovedByItemGetgems NftApprovedByItem = "getgems" - NftApprovedByItemTonkeeper NftApprovedByItem = "tonkeeper" - NftApprovedByItemTonDiamonds NftApprovedByItem = "ton.diamonds" + NftApprovedByItemGetgems NftApprovedByItem = "getgems" + NftApprovedByItemTonkeeper NftApprovedByItem = "tonkeeper" ) // AllValues returns all NftApprovedByItem values. @@ -9071,7 +9892,6 @@ func (NftApprovedByItem) AllValues() []NftApprovedByItem { return []NftApprovedByItem{ NftApprovedByItemGetgems, NftApprovedByItemTonkeeper, - NftApprovedByItemTonDiamonds, } } @@ -9082,8 +9902,6 @@ func (s NftApprovedByItem) MarshalText() ([]byte, error) { return []byte(s), nil case NftApprovedByItemTonkeeper: return []byte(s), nil - case NftApprovedByItemTonDiamonds: - return []byte(s), nil default: return nil, errors.Errorf("invalid value: %q", s) } @@ -9098,9 +9916,6 @@ func (s *NftApprovedByItem) UnmarshalText(data []byte) error { case NftApprovedByItemTonkeeper: *s = NftApprovedByItemTonkeeper return nil - case NftApprovedByItemTonDiamonds: - *s = NftApprovedByItemTonDiamonds - return nil default: return errors.Errorf("invalid value: %q", data) } @@ -9215,18 +10030,22 @@ func (s *NftCollections) SetNftCollections(val []NftCollection) { // Ref: #/components/schemas/NftItem type NftItem struct { - Address string `json:"address"` - Index int64 `json:"index"` - Owner OptAccountAddress `json:"owner"` - Collection OptNftItemCollection `json:"collection"` - Verified bool `json:"verified"` - Metadata NftItemMetadata `json:"metadata"` - Sale OptSale `json:"sale"` - Previews []ImagePreview `json:"previews"` - DNS OptString `json:"dns"` - ApprovedBy NftApprovedBy `json:"approved_by"` - IncludeCnft OptBool `json:"include_cnft"` - Trust TrustType `json:"trust"` + Address string `json:"address"` + Index int64 `json:"index"` + Owner OptAccountAddress `json:"owner"` + Collection OptNftItemCollection `json:"collection"` + // Collection master contract confirmed that this item is part of collection. + Verified bool `json:"verified"` + Metadata NftItemMetadata `json:"metadata"` + Sale OptSale `json:"sale"` + Previews []ImagePreview `json:"previews"` + DNS OptString `json:"dns"` + // Please use trust field. + // + // Deprecated: schema marks this property as deprecated. + ApprovedBy []NftItemApprovedByItem `json:"approved_by"` + IncludeCnft OptBool `json:"include_cnft"` + Trust TrustType `json:"trust"` } // GetAddress returns the value of Address. @@ -9275,7 +10094,7 @@ func (s *NftItem) GetDNS() OptString { } // GetApprovedBy returns the value of ApprovedBy. -func (s *NftItem) GetApprovedBy() NftApprovedBy { +func (s *NftItem) GetApprovedBy() []NftItemApprovedByItem { return s.ApprovedBy } @@ -9335,7 +10154,7 @@ func (s *NftItem) SetDNS(val OptString) { } // SetApprovedBy sets the value of ApprovedBy. -func (s *NftItem) SetApprovedBy(val NftApprovedBy) { +func (s *NftItem) SetApprovedBy(val []NftItemApprovedByItem) { s.ApprovedBy = val } @@ -9349,6 +10168,47 @@ func (s *NftItem) SetTrust(val TrustType) { s.Trust = val } +type NftItemApprovedByItem string + +const ( + NftItemApprovedByItemGetgems NftItemApprovedByItem = "getgems" + NftItemApprovedByItemTonkeeper NftItemApprovedByItem = "tonkeeper" +) + +// AllValues returns all NftItemApprovedByItem values. +func (NftItemApprovedByItem) AllValues() []NftItemApprovedByItem { + return []NftItemApprovedByItem{ + NftItemApprovedByItemGetgems, + NftItemApprovedByItemTonkeeper, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s NftItemApprovedByItem) MarshalText() ([]byte, error) { + switch s { + case NftItemApprovedByItemGetgems: + return []byte(s), nil + case NftItemApprovedByItemTonkeeper: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *NftItemApprovedByItem) UnmarshalText(data []byte) error { + switch NftItemApprovedByItem(data) { + case NftItemApprovedByItemGetgems: + *s = NftItemApprovedByItemGetgems + return nil + case NftItemApprovedByItemTonkeeper: + *s = NftItemApprovedByItemTonkeeper + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + type NftItemCollection struct { Address string `json:"address"` Name string `json:"name"` @@ -9493,6 +10353,113 @@ func (s *NftItems) SetNftItems(val []NftItem) { s.NftItems = val } +// Ref: #/components/schemas/NftOperation +type NftOperation struct { + Operation string `json:"operation"` + Utime int64 `json:"utime"` + Lt int64 `json:"lt"` + TransactionHash string `json:"transaction_hash"` + Source OptAccountAddress `json:"source"` + Destination OptAccountAddress `json:"destination"` + Item NftItem `json:"item"` +} + +// GetOperation returns the value of Operation. +func (s *NftOperation) GetOperation() string { + return s.Operation +} + +// GetUtime returns the value of Utime. +func (s *NftOperation) GetUtime() int64 { + return s.Utime +} + +// GetLt returns the value of Lt. +func (s *NftOperation) GetLt() int64 { + return s.Lt +} + +// GetTransactionHash returns the value of TransactionHash. +func (s *NftOperation) GetTransactionHash() string { + return s.TransactionHash +} + +// GetSource returns the value of Source. +func (s *NftOperation) GetSource() OptAccountAddress { + return s.Source +} + +// GetDestination returns the value of Destination. +func (s *NftOperation) GetDestination() OptAccountAddress { + return s.Destination +} + +// GetItem returns the value of Item. +func (s *NftOperation) GetItem() NftItem { + return s.Item +} + +// SetOperation sets the value of Operation. +func (s *NftOperation) SetOperation(val string) { + s.Operation = val +} + +// SetUtime sets the value of Utime. +func (s *NftOperation) SetUtime(val int64) { + s.Utime = val +} + +// SetLt sets the value of Lt. +func (s *NftOperation) SetLt(val int64) { + s.Lt = val +} + +// SetTransactionHash sets the value of TransactionHash. +func (s *NftOperation) SetTransactionHash(val string) { + s.TransactionHash = val +} + +// SetSource sets the value of Source. +func (s *NftOperation) SetSource(val OptAccountAddress) { + s.Source = val +} + +// SetDestination sets the value of Destination. +func (s *NftOperation) SetDestination(val OptAccountAddress) { + s.Destination = val +} + +// SetItem sets the value of Item. +func (s *NftOperation) SetItem(val NftItem) { + s.Item = val +} + +// Ref: #/components/schemas/NftOperations +type NftOperations struct { + Operations []NftOperation `json:"operations"` + NextFrom OptInt64 `json:"next_from"` +} + +// GetOperations returns the value of Operations. +func (s *NftOperations) GetOperations() []NftOperation { + return s.Operations +} + +// GetNextFrom returns the value of NextFrom. +func (s *NftOperations) GetNextFrom() OptInt64 { + return s.NextFrom +} + +// SetOperations sets the value of Operations. +func (s *NftOperations) SetOperations(val []NftOperation) { + s.Operations = val +} + +// SetNextFrom sets the value of NextFrom. +func (s *NftOperations) SetNextFrom(val OptInt64) { + s.NextFrom = val +} + // Ref: #/components/schemas/NftPurchaseAction type NftPurchaseAction struct { AuctionType NftPurchaseActionAuctionType `json:"auction_type"` @@ -9745,38 +10712,38 @@ func (o OptActionPhase) Or(d ActionPhase) ActionPhase { return d } -// NewOptAuctionBidAction returns new OptAuctionBidAction with value set to v. -func NewOptAuctionBidAction(v AuctionBidAction) OptAuctionBidAction { - return OptAuctionBidAction{ +// NewOptAddExtensionAction returns new OptAddExtensionAction with value set to v. +func NewOptAddExtensionAction(v AddExtensionAction) OptAddExtensionAction { + return OptAddExtensionAction{ Value: v, Set: true, } } -// OptAuctionBidAction is optional AuctionBidAction. -type OptAuctionBidAction struct { - Value AuctionBidAction +// OptAddExtensionAction is optional AddExtensionAction. +type OptAddExtensionAction struct { + Value AddExtensionAction Set bool } -// IsSet returns true if OptAuctionBidAction was set. -func (o OptAuctionBidAction) IsSet() bool { return o.Set } +// IsSet returns true if OptAddExtensionAction was set. +func (o OptAddExtensionAction) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptAuctionBidAction) Reset() { - var v AuctionBidAction +func (o *OptAddExtensionAction) Reset() { + var v AddExtensionAction o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptAuctionBidAction) SetTo(v AuctionBidAction) { +func (o *OptAddExtensionAction) SetTo(v AddExtensionAction) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptAuctionBidAction) Get() (v AuctionBidAction, ok bool) { +func (o OptAddExtensionAction) Get() (v AddExtensionAction, ok bool) { if !o.Set { return v, false } @@ -9784,45 +10751,45 @@ func (o OptAuctionBidAction) Get() (v AuctionBidAction, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptAuctionBidAction) Or(d AuctionBidAction) AuctionBidAction { +func (o OptAddExtensionAction) Or(d AddExtensionAction) AddExtensionAction { if v, ok := o.Get(); ok { return v } return d } -// NewOptBlockCurrencyCollection returns new OptBlockCurrencyCollection with value set to v. -func NewOptBlockCurrencyCollection(v BlockCurrencyCollection) OptBlockCurrencyCollection { - return OptBlockCurrencyCollection{ +// NewOptAuctionBidAction returns new OptAuctionBidAction with value set to v. +func NewOptAuctionBidAction(v AuctionBidAction) OptAuctionBidAction { + return OptAuctionBidAction{ Value: v, Set: true, } } -// OptBlockCurrencyCollection is optional BlockCurrencyCollection. -type OptBlockCurrencyCollection struct { - Value BlockCurrencyCollection +// OptAuctionBidAction is optional AuctionBidAction. +type OptAuctionBidAction struct { + Value AuctionBidAction Set bool } -// IsSet returns true if OptBlockCurrencyCollection was set. -func (o OptBlockCurrencyCollection) IsSet() bool { return o.Set } +// IsSet returns true if OptAuctionBidAction was set. +func (o OptAuctionBidAction) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptBlockCurrencyCollection) Reset() { - var v BlockCurrencyCollection +func (o *OptAuctionBidAction) Reset() { + var v AuctionBidAction o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptBlockCurrencyCollection) SetTo(v BlockCurrencyCollection) { +func (o *OptAuctionBidAction) SetTo(v AuctionBidAction) { 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) { +func (o OptAuctionBidAction) Get() (v AuctionBidAction, ok bool) { if !o.Set { return v, false } @@ -9830,45 +10797,45 @@ func (o OptBlockCurrencyCollection) Get() (v BlockCurrencyCollection, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptBlockCurrencyCollection) Or(d BlockCurrencyCollection) BlockCurrencyCollection { +func (o OptAuctionBidAction) Or(d AuctionBidAction) AuctionBidAction { 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{ +// NewOptBlockCurrencyCollection returns new OptBlockCurrencyCollection with value set to v. +func NewOptBlockCurrencyCollection(v BlockCurrencyCollection) OptBlockCurrencyCollection { + return OptBlockCurrencyCollection{ Value: v, Set: true, } } -// OptBlockchainAccountInspectCompiler is optional BlockchainAccountInspectCompiler. -type OptBlockchainAccountInspectCompiler struct { - Value BlockchainAccountInspectCompiler +// OptBlockCurrencyCollection is optional BlockCurrencyCollection. +type OptBlockCurrencyCollection struct { + Value BlockCurrencyCollection Set bool } -// IsSet returns true if OptBlockchainAccountInspectCompiler was set. -func (o OptBlockchainAccountInspectCompiler) IsSet() bool { return o.Set } +// IsSet returns true if OptBlockCurrencyCollection was set. +func (o OptBlockCurrencyCollection) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptBlockchainAccountInspectCompiler) Reset() { - var v BlockchainAccountInspectCompiler +func (o *OptBlockCurrencyCollection) Reset() { + var v BlockCurrencyCollection o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptBlockchainAccountInspectCompiler) SetTo(v BlockchainAccountInspectCompiler) { +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 OptBlockchainAccountInspectCompiler) Get() (v BlockchainAccountInspectCompiler, ok bool) { +func (o OptBlockCurrencyCollection) Get() (v BlockCurrencyCollection, ok bool) { if !o.Set { return v, false } @@ -9876,7 +10843,7 @@ func (o OptBlockchainAccountInspectCompiler) Get() (v BlockchainAccountInspectCo } // Or returns value if set, or given parameter if does not. -func (o OptBlockchainAccountInspectCompiler) Or(d BlockchainAccountInspectCompiler) BlockchainAccountInspectCompiler { +func (o OptBlockCurrencyCollection) Or(d BlockCurrencyCollection) BlockCurrencyCollection { if v, ok := o.Get(); ok { return v } @@ -10803,6 +11770,52 @@ func (o OptBlockchainConfig43) Or(d BlockchainConfig43) BlockchainConfig43 { return d } +// NewOptBlockchainConfig45 returns new OptBlockchainConfig45 with value set to v. +func NewOptBlockchainConfig45(v BlockchainConfig45) OptBlockchainConfig45 { + return OptBlockchainConfig45{ + Value: v, + Set: true, + } +} + +// OptBlockchainConfig45 is optional BlockchainConfig45. +type OptBlockchainConfig45 struct { + Value BlockchainConfig45 + Set bool +} + +// IsSet returns true if OptBlockchainConfig45 was set. +func (o OptBlockchainConfig45) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptBlockchainConfig45) Reset() { + var v BlockchainConfig45 + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptBlockchainConfig45) SetTo(v BlockchainConfig45) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptBlockchainConfig45) Get() (v BlockchainConfig45, 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 OptBlockchainConfig45) Or(d BlockchainConfig45) BlockchainConfig45 { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptBlockchainConfig5 returns new OptBlockchainConfig5 with value set to v. func NewOptBlockchainConfig5(v BlockchainConfig5) OptBlockchainConfig5 { return OptBlockchainConfig5{ @@ -11271,76 +12284,30 @@ func NewOptBlockchainConfig9(v BlockchainConfig9) OptBlockchainConfig9 { } } -// OptBlockchainConfig9 is optional BlockchainConfig9. -type OptBlockchainConfig9 struct { - Value BlockchainConfig9 - Set bool -} - -// IsSet returns true if OptBlockchainConfig9 was set. -func (o OptBlockchainConfig9) IsSet() bool { return o.Set } - -// Reset unsets value. -func (o *OptBlockchainConfig9) Reset() { - var v BlockchainConfig9 - o.Value = v - o.Set = false -} - -// SetTo sets value to v. -func (o *OptBlockchainConfig9) SetTo(v BlockchainConfig9) { - o.Set = true - o.Value = v -} - -// Get returns value and boolean that denotes whether value was set. -func (o OptBlockchainConfig9) Get() (v BlockchainConfig9, 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 OptBlockchainConfig9) Or(d BlockchainConfig9) BlockchainConfig9 { - if v, ok := o.Get(); ok { - return v - } - return d -} - -// NewOptBlockchainRawAccountExtraBalance returns new OptBlockchainRawAccountExtraBalance with value set to v. -func NewOptBlockchainRawAccountExtraBalance(v BlockchainRawAccountExtraBalance) OptBlockchainRawAccountExtraBalance { - return OptBlockchainRawAccountExtraBalance{ - Value: v, - Set: true, - } -} - -// OptBlockchainRawAccountExtraBalance is optional BlockchainRawAccountExtraBalance. -type OptBlockchainRawAccountExtraBalance struct { - Value BlockchainRawAccountExtraBalance +// OptBlockchainConfig9 is optional BlockchainConfig9. +type OptBlockchainConfig9 struct { + Value BlockchainConfig9 Set bool } -// IsSet returns true if OptBlockchainRawAccountExtraBalance was set. -func (o OptBlockchainRawAccountExtraBalance) IsSet() bool { return o.Set } +// IsSet returns true if OptBlockchainConfig9 was set. +func (o OptBlockchainConfig9) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptBlockchainRawAccountExtraBalance) Reset() { - var v BlockchainRawAccountExtraBalance +func (o *OptBlockchainConfig9) Reset() { + var v BlockchainConfig9 o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptBlockchainRawAccountExtraBalance) SetTo(v BlockchainRawAccountExtraBalance) { +func (o *OptBlockchainConfig9) SetTo(v BlockchainConfig9) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptBlockchainRawAccountExtraBalance) Get() (v BlockchainRawAccountExtraBalance, ok bool) { +func (o OptBlockchainConfig9) Get() (v BlockchainConfig9, ok bool) { if !o.Set { return v, false } @@ -11348,7 +12315,7 @@ func (o OptBlockchainRawAccountExtraBalance) Get() (v BlockchainRawAccountExtraB } // Or returns value if set, or given parameter if does not. -func (o OptBlockchainRawAccountExtraBalance) Or(d BlockchainRawAccountExtraBalance) BlockchainRawAccountExtraBalance { +func (o OptBlockchainConfig9) Or(d BlockchainConfig9) BlockchainConfig9 { if v, ok := o.Get(); ok { return v } @@ -11783,24 +12750,300 @@ type OptDecodedMessageExtInMsgDecodedWalletV4 struct { Set bool } -// IsSet returns true if OptDecodedMessageExtInMsgDecodedWalletV4 was set. -func (o OptDecodedMessageExtInMsgDecodedWalletV4) IsSet() bool { return o.Set } +// 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 +} + +// NewOptDecodedMessageExtInMsgDecodedWalletV5 returns new OptDecodedMessageExtInMsgDecodedWalletV5 with value set to v. +func NewOptDecodedMessageExtInMsgDecodedWalletV5(v DecodedMessageExtInMsgDecodedWalletV5) OptDecodedMessageExtInMsgDecodedWalletV5 { + return OptDecodedMessageExtInMsgDecodedWalletV5{ + Value: v, + Set: true, + } +} + +// OptDecodedMessageExtInMsgDecodedWalletV5 is optional DecodedMessageExtInMsgDecodedWalletV5. +type OptDecodedMessageExtInMsgDecodedWalletV5 struct { + Value DecodedMessageExtInMsgDecodedWalletV5 + Set bool +} + +// IsSet returns true if OptDecodedMessageExtInMsgDecodedWalletV5 was set. +func (o OptDecodedMessageExtInMsgDecodedWalletV5) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptDecodedMessageExtInMsgDecodedWalletV5) Reset() { + var v DecodedMessageExtInMsgDecodedWalletV5 + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptDecodedMessageExtInMsgDecodedWalletV5) SetTo(v DecodedMessageExtInMsgDecodedWalletV5) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptDecodedMessageExtInMsgDecodedWalletV5) Get() (v DecodedMessageExtInMsgDecodedWalletV5, 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 OptDecodedMessageExtInMsgDecodedWalletV5) Or(d DecodedMessageExtInMsgDecodedWalletV5) DecodedMessageExtInMsgDecodedWalletV5 { + 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{ + Value: v, + Set: true, + } +} + +// OptDepositStakeAction is optional DepositStakeAction. +type OptDepositStakeAction struct { + Value DepositStakeAction + Set bool +} + +// IsSet returns true if OptDepositStakeAction was set. +func (o OptDepositStakeAction) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptDepositStakeAction) Reset() { + var v DepositStakeAction + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptDepositStakeAction) SetTo(v DepositStakeAction) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptDepositStakeAction) Get() (v DepositStakeAction, 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 OptDepositStakeAction) Or(d DepositStakeAction) DepositStakeAction { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptDepositTokenStakeAction returns new OptDepositTokenStakeAction with value set to v. +func NewOptDepositTokenStakeAction(v DepositTokenStakeAction) OptDepositTokenStakeAction { + return OptDepositTokenStakeAction{ + Value: v, + Set: true, + } +} + +// OptDepositTokenStakeAction is optional DepositTokenStakeAction. +type OptDepositTokenStakeAction struct { + Value DepositTokenStakeAction + Set bool +} + +// IsSet returns true if OptDepositTokenStakeAction was set. +func (o OptDepositTokenStakeAction) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptDepositTokenStakeAction) Reset() { + var v DepositTokenStakeAction + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptDepositTokenStakeAction) SetTo(v DepositTokenStakeAction) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptDepositTokenStakeAction) Get() (v DepositTokenStakeAction, 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 OptDepositTokenStakeAction) Or(d DepositTokenStakeAction) DepositTokenStakeAction { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptDomainRenewAction returns new OptDomainRenewAction with value set to v. +func NewOptDomainRenewAction(v DomainRenewAction) OptDomainRenewAction { + return OptDomainRenewAction{ + Value: v, + Set: true, + } +} + +// OptDomainRenewAction is optional DomainRenewAction. +type OptDomainRenewAction struct { + Value DomainRenewAction + Set bool +} + +// IsSet returns true if OptDomainRenewAction was set. +func (o OptDomainRenewAction) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptDomainRenewAction) Reset() { + var v DomainRenewAction + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptDomainRenewAction) SetTo(v DomainRenewAction) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptDomainRenewAction) Get() (v DomainRenewAction, 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 OptDomainRenewAction) Or(d DomainRenewAction) DomainRenewAction { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptElectionsDepositStakeAction returns new OptElectionsDepositStakeAction with value set to v. +func NewOptElectionsDepositStakeAction(v ElectionsDepositStakeAction) OptElectionsDepositStakeAction { + return OptElectionsDepositStakeAction{ + Value: v, + Set: true, + } +} + +// OptElectionsDepositStakeAction is optional ElectionsDepositStakeAction. +type OptElectionsDepositStakeAction struct { + Value ElectionsDepositStakeAction + Set bool +} + +// IsSet returns true if OptElectionsDepositStakeAction was set. +func (o OptElectionsDepositStakeAction) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptElectionsDepositStakeAction) Reset() { + var v ElectionsDepositStakeAction + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptElectionsDepositStakeAction) SetTo(v ElectionsDepositStakeAction) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptElectionsDepositStakeAction) Get() (v ElectionsDepositStakeAction, 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 OptElectionsDepositStakeAction) Or(d ElectionsDepositStakeAction) ElectionsDepositStakeAction { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptElectionsRecoverStakeAction returns new OptElectionsRecoverStakeAction with value set to v. +func NewOptElectionsRecoverStakeAction(v ElectionsRecoverStakeAction) OptElectionsRecoverStakeAction { + return OptElectionsRecoverStakeAction{ + Value: v, + Set: true, + } +} + +// OptElectionsRecoverStakeAction is optional ElectionsRecoverStakeAction. +type OptElectionsRecoverStakeAction struct { + Value ElectionsRecoverStakeAction + Set bool +} + +// IsSet returns true if OptElectionsRecoverStakeAction was set. +func (o OptElectionsRecoverStakeAction) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptDecodedMessageExtInMsgDecodedWalletV4) Reset() { - var v DecodedMessageExtInMsgDecodedWalletV4 +func (o *OptElectionsRecoverStakeAction) Reset() { + var v ElectionsRecoverStakeAction o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptDecodedMessageExtInMsgDecodedWalletV4) SetTo(v DecodedMessageExtInMsgDecodedWalletV4) { +func (o *OptElectionsRecoverStakeAction) SetTo(v ElectionsRecoverStakeAction) { 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) { +func (o OptElectionsRecoverStakeAction) Get() (v ElectionsRecoverStakeAction, ok bool) { if !o.Set { return v, false } @@ -11808,45 +13051,45 @@ func (o OptDecodedMessageExtInMsgDecodedWalletV4) Get() (v DecodedMessageExtInMs } // Or returns value if set, or given parameter if does not. -func (o OptDecodedMessageExtInMsgDecodedWalletV4) Or(d DecodedMessageExtInMsgDecodedWalletV4) DecodedMessageExtInMsgDecodedWalletV4 { +func (o OptElectionsRecoverStakeAction) Or(d ElectionsRecoverStakeAction) ElectionsRecoverStakeAction { 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{ +// NewOptEncryptedComment returns new OptEncryptedComment with value set to v. +func NewOptEncryptedComment(v EncryptedComment) OptEncryptedComment { + return OptEncryptedComment{ Value: v, Set: true, } } -// OptDepositStakeAction is optional DepositStakeAction. -type OptDepositStakeAction struct { - Value DepositStakeAction +// OptEncryptedComment is optional EncryptedComment. +type OptEncryptedComment struct { + Value EncryptedComment Set bool } -// IsSet returns true if OptDepositStakeAction was set. -func (o OptDepositStakeAction) IsSet() bool { return o.Set } +// IsSet returns true if OptEncryptedComment was set. +func (o OptEncryptedComment) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptDepositStakeAction) Reset() { - var v DepositStakeAction +func (o *OptEncryptedComment) Reset() { + var v EncryptedComment o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptDepositStakeAction) SetTo(v DepositStakeAction) { +func (o *OptEncryptedComment) SetTo(v EncryptedComment) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptDepositStakeAction) Get() (v DepositStakeAction, ok bool) { +func (o OptEncryptedComment) Get() (v EncryptedComment, ok bool) { if !o.Set { return v, false } @@ -11854,45 +13097,45 @@ func (o OptDepositStakeAction) Get() (v DepositStakeAction, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptDepositStakeAction) Or(d DepositStakeAction) DepositStakeAction { +func (o OptEncryptedComment) Or(d EncryptedComment) EncryptedComment { if v, ok := o.Get(); ok { return v } return d } -// NewOptDomainRenewAction returns new OptDomainRenewAction with value set to v. -func NewOptDomainRenewAction(v DomainRenewAction) OptDomainRenewAction { - return OptDomainRenewAction{ +// NewOptExecGetMethodWithBodyForBlockchainAccountReq returns new OptExecGetMethodWithBodyForBlockchainAccountReq with value set to v. +func NewOptExecGetMethodWithBodyForBlockchainAccountReq(v ExecGetMethodWithBodyForBlockchainAccountReq) OptExecGetMethodWithBodyForBlockchainAccountReq { + return OptExecGetMethodWithBodyForBlockchainAccountReq{ Value: v, Set: true, } } -// OptDomainRenewAction is optional DomainRenewAction. -type OptDomainRenewAction struct { - Value DomainRenewAction +// OptExecGetMethodWithBodyForBlockchainAccountReq is optional ExecGetMethodWithBodyForBlockchainAccountReq. +type OptExecGetMethodWithBodyForBlockchainAccountReq struct { + Value ExecGetMethodWithBodyForBlockchainAccountReq Set bool } -// IsSet returns true if OptDomainRenewAction was set. -func (o OptDomainRenewAction) IsSet() bool { return o.Set } +// IsSet returns true if OptExecGetMethodWithBodyForBlockchainAccountReq was set. +func (o OptExecGetMethodWithBodyForBlockchainAccountReq) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptDomainRenewAction) Reset() { - var v DomainRenewAction +func (o *OptExecGetMethodWithBodyForBlockchainAccountReq) Reset() { + var v ExecGetMethodWithBodyForBlockchainAccountReq o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptDomainRenewAction) SetTo(v DomainRenewAction) { +func (o *OptExecGetMethodWithBodyForBlockchainAccountReq) SetTo(v ExecGetMethodWithBodyForBlockchainAccountReq) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptDomainRenewAction) Get() (v DomainRenewAction, ok bool) { +func (o OptExecGetMethodWithBodyForBlockchainAccountReq) Get() (v ExecGetMethodWithBodyForBlockchainAccountReq, ok bool) { if !o.Set { return v, false } @@ -11900,45 +13143,45 @@ func (o OptDomainRenewAction) Get() (v DomainRenewAction, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptDomainRenewAction) Or(d DomainRenewAction) DomainRenewAction { +func (o OptExecGetMethodWithBodyForBlockchainAccountReq) Or(d ExecGetMethodWithBodyForBlockchainAccountReq) ExecGetMethodWithBodyForBlockchainAccountReq { if v, ok := o.Get(); ok { return v } return d } -// NewOptElectionsDepositStakeAction returns new OptElectionsDepositStakeAction with value set to v. -func NewOptElectionsDepositStakeAction(v ElectionsDepositStakeAction) OptElectionsDepositStakeAction { - return OptElectionsDepositStakeAction{ +// NewOptExtraCurrencyTransferAction returns new OptExtraCurrencyTransferAction with value set to v. +func NewOptExtraCurrencyTransferAction(v ExtraCurrencyTransferAction) OptExtraCurrencyTransferAction { + return OptExtraCurrencyTransferAction{ Value: v, Set: true, } } -// OptElectionsDepositStakeAction is optional ElectionsDepositStakeAction. -type OptElectionsDepositStakeAction struct { - Value ElectionsDepositStakeAction +// OptExtraCurrencyTransferAction is optional ExtraCurrencyTransferAction. +type OptExtraCurrencyTransferAction struct { + Value ExtraCurrencyTransferAction Set bool } -// IsSet returns true if OptElectionsDepositStakeAction was set. -func (o OptElectionsDepositStakeAction) IsSet() bool { return o.Set } +// IsSet returns true if OptExtraCurrencyTransferAction was set. +func (o OptExtraCurrencyTransferAction) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptElectionsDepositStakeAction) Reset() { - var v ElectionsDepositStakeAction +func (o *OptExtraCurrencyTransferAction) Reset() { + var v ExtraCurrencyTransferAction o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptElectionsDepositStakeAction) SetTo(v ElectionsDepositStakeAction) { +func (o *OptExtraCurrencyTransferAction) SetTo(v ExtraCurrencyTransferAction) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptElectionsDepositStakeAction) Get() (v ElectionsDepositStakeAction, ok bool) { +func (o OptExtraCurrencyTransferAction) Get() (v ExtraCurrencyTransferAction, ok bool) { if !o.Set { return v, false } @@ -11946,45 +13189,45 @@ func (o OptElectionsDepositStakeAction) Get() (v ElectionsDepositStakeAction, ok } // Or returns value if set, or given parameter if does not. -func (o OptElectionsDepositStakeAction) Or(d ElectionsDepositStakeAction) ElectionsDepositStakeAction { +func (o OptExtraCurrencyTransferAction) Or(d ExtraCurrencyTransferAction) ExtraCurrencyTransferAction { if v, ok := o.Get(); ok { return v } return d } -// NewOptElectionsRecoverStakeAction returns new OptElectionsRecoverStakeAction with value set to v. -func NewOptElectionsRecoverStakeAction(v ElectionsRecoverStakeAction) OptElectionsRecoverStakeAction { - return OptElectionsRecoverStakeAction{ +// NewOptFloat32 returns new OptFloat32 with value set to v. +func NewOptFloat32(v float32) OptFloat32 { + return OptFloat32{ Value: v, Set: true, } } -// OptElectionsRecoverStakeAction is optional ElectionsRecoverStakeAction. -type OptElectionsRecoverStakeAction struct { - Value ElectionsRecoverStakeAction +// OptFloat32 is optional float32. +type OptFloat32 struct { + Value float32 Set bool } -// IsSet returns true if OptElectionsRecoverStakeAction was set. -func (o OptElectionsRecoverStakeAction) IsSet() bool { return o.Set } +// IsSet returns true if OptFloat32 was set. +func (o OptFloat32) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptElectionsRecoverStakeAction) Reset() { - var v ElectionsRecoverStakeAction +func (o *OptFloat32) Reset() { + var v float32 o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptElectionsRecoverStakeAction) SetTo(v ElectionsRecoverStakeAction) { +func (o *OptFloat32) SetTo(v float32) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptElectionsRecoverStakeAction) Get() (v ElectionsRecoverStakeAction, ok bool) { +func (o OptFloat32) Get() (v float32, ok bool) { if !o.Set { return v, false } @@ -11992,45 +13235,45 @@ func (o OptElectionsRecoverStakeAction) Get() (v ElectionsRecoverStakeAction, ok } // Or returns value if set, or given parameter if does not. -func (o OptElectionsRecoverStakeAction) Or(d ElectionsRecoverStakeAction) ElectionsRecoverStakeAction { +func (o OptFloat32) Or(d float32) float32 { if v, ok := o.Get(); ok { return v } return d } -// NewOptEncryptedComment returns new OptEncryptedComment with value set to v. -func NewOptEncryptedComment(v EncryptedComment) OptEncryptedComment { - return OptEncryptedComment{ +// NewOptGasRelayAction returns new OptGasRelayAction with value set to v. +func NewOptGasRelayAction(v GasRelayAction) OptGasRelayAction { + return OptGasRelayAction{ Value: v, Set: true, } } -// OptEncryptedComment is optional EncryptedComment. -type OptEncryptedComment struct { - Value EncryptedComment +// OptGasRelayAction is optional GasRelayAction. +type OptGasRelayAction struct { + Value GasRelayAction Set bool } -// IsSet returns true if OptEncryptedComment was set. -func (o OptEncryptedComment) IsSet() bool { return o.Set } +// IsSet returns true if OptGasRelayAction was set. +func (o OptGasRelayAction) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptEncryptedComment) Reset() { - var v EncryptedComment +func (o *OptGasRelayAction) Reset() { + var v GasRelayAction o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptEncryptedComment) SetTo(v EncryptedComment) { +func (o *OptGasRelayAction) SetTo(v GasRelayAction) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptEncryptedComment) Get() (v EncryptedComment, ok bool) { +func (o OptGasRelayAction) Get() (v GasRelayAction, ok bool) { if !o.Set { return v, false } @@ -12038,7 +13281,7 @@ func (o OptEncryptedComment) Get() (v EncryptedComment, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptEncryptedComment) Or(d EncryptedComment) EncryptedComment { +func (o OptGasRelayAction) Or(d GasRelayAction) GasRelayAction { if v, ok := o.Get(); ok { return v } @@ -12137,38 +13380,38 @@ func (o OptGetBlockchainAccountTransactionsSortOrder) Or(d GetBlockchainAccountT return d } -// NewOptGetNftItemsByAddressesReq returns new OptGetNftItemsByAddressesReq with value set to v. -func NewOptGetNftItemsByAddressesReq(v GetNftItemsByAddressesReq) OptGetNftItemsByAddressesReq { - return OptGetNftItemsByAddressesReq{ +// NewOptGetJettonInfosByAddressesReq returns new OptGetJettonInfosByAddressesReq with value set to v. +func NewOptGetJettonInfosByAddressesReq(v GetJettonInfosByAddressesReq) OptGetJettonInfosByAddressesReq { + return OptGetJettonInfosByAddressesReq{ Value: v, Set: true, } } -// OptGetNftItemsByAddressesReq is optional GetNftItemsByAddressesReq. -type OptGetNftItemsByAddressesReq struct { - Value GetNftItemsByAddressesReq +// OptGetJettonInfosByAddressesReq is optional GetJettonInfosByAddressesReq. +type OptGetJettonInfosByAddressesReq struct { + Value GetJettonInfosByAddressesReq Set bool } -// IsSet returns true if OptGetNftItemsByAddressesReq was set. -func (o OptGetNftItemsByAddressesReq) IsSet() bool { return o.Set } +// IsSet returns true if OptGetJettonInfosByAddressesReq was set. +func (o OptGetJettonInfosByAddressesReq) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptGetNftItemsByAddressesReq) Reset() { - var v GetNftItemsByAddressesReq +func (o *OptGetJettonInfosByAddressesReq) Reset() { + var v GetJettonInfosByAddressesReq o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptGetNftItemsByAddressesReq) SetTo(v GetNftItemsByAddressesReq) { +func (o *OptGetJettonInfosByAddressesReq) SetTo(v GetJettonInfosByAddressesReq) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptGetNftItemsByAddressesReq) Get() (v GetNftItemsByAddressesReq, ok bool) { +func (o OptGetJettonInfosByAddressesReq) Get() (v GetJettonInfosByAddressesReq, ok bool) { if !o.Set { return v, false } @@ -12176,45 +13419,45 @@ func (o OptGetNftItemsByAddressesReq) Get() (v GetNftItemsByAddressesReq, ok boo } // Or returns value if set, or given parameter if does not. -func (o OptGetNftItemsByAddressesReq) Or(d GetNftItemsByAddressesReq) GetNftItemsByAddressesReq { +func (o OptGetJettonInfosByAddressesReq) Or(d GetJettonInfosByAddressesReq) GetJettonInfosByAddressesReq { if v, ok := o.Get(); ok { return v } return d } -// NewOptInscriptionMintAction returns new OptInscriptionMintAction with value set to v. -func NewOptInscriptionMintAction(v InscriptionMintAction) OptInscriptionMintAction { - return OptInscriptionMintAction{ +// NewOptGetNftCollectionItemsByAddressesReq returns new OptGetNftCollectionItemsByAddressesReq with value set to v. +func NewOptGetNftCollectionItemsByAddressesReq(v GetNftCollectionItemsByAddressesReq) OptGetNftCollectionItemsByAddressesReq { + return OptGetNftCollectionItemsByAddressesReq{ Value: v, Set: true, } } -// OptInscriptionMintAction is optional InscriptionMintAction. -type OptInscriptionMintAction struct { - Value InscriptionMintAction +// OptGetNftCollectionItemsByAddressesReq is optional GetNftCollectionItemsByAddressesReq. +type OptGetNftCollectionItemsByAddressesReq struct { + Value GetNftCollectionItemsByAddressesReq Set bool } -// IsSet returns true if OptInscriptionMintAction was set. -func (o OptInscriptionMintAction) IsSet() bool { return o.Set } +// IsSet returns true if OptGetNftCollectionItemsByAddressesReq was set. +func (o OptGetNftCollectionItemsByAddressesReq) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptInscriptionMintAction) Reset() { - var v InscriptionMintAction +func (o *OptGetNftCollectionItemsByAddressesReq) Reset() { + var v GetNftCollectionItemsByAddressesReq o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptInscriptionMintAction) SetTo(v InscriptionMintAction) { +func (o *OptGetNftCollectionItemsByAddressesReq) SetTo(v GetNftCollectionItemsByAddressesReq) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptInscriptionMintAction) Get() (v InscriptionMintAction, ok bool) { +func (o OptGetNftCollectionItemsByAddressesReq) Get() (v GetNftCollectionItemsByAddressesReq, ok bool) { if !o.Set { return v, false } @@ -12222,45 +13465,45 @@ func (o OptInscriptionMintAction) Get() (v InscriptionMintAction, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptInscriptionMintAction) Or(d InscriptionMintAction) InscriptionMintAction { +func (o OptGetNftCollectionItemsByAddressesReq) Or(d GetNftCollectionItemsByAddressesReq) GetNftCollectionItemsByAddressesReq { if v, ok := o.Get(); ok { return v } return d } -// NewOptInscriptionTransferAction returns new OptInscriptionTransferAction with value set to v. -func NewOptInscriptionTransferAction(v InscriptionTransferAction) OptInscriptionTransferAction { - return OptInscriptionTransferAction{ +// NewOptGetNftItemsByAddressesReq returns new OptGetNftItemsByAddressesReq with value set to v. +func NewOptGetNftItemsByAddressesReq(v GetNftItemsByAddressesReq) OptGetNftItemsByAddressesReq { + return OptGetNftItemsByAddressesReq{ Value: v, Set: true, } } -// OptInscriptionTransferAction is optional InscriptionTransferAction. -type OptInscriptionTransferAction struct { - Value InscriptionTransferAction +// OptGetNftItemsByAddressesReq is optional GetNftItemsByAddressesReq. +type OptGetNftItemsByAddressesReq struct { + Value GetNftItemsByAddressesReq Set bool } -// IsSet returns true if OptInscriptionTransferAction was set. -func (o OptInscriptionTransferAction) IsSet() bool { return o.Set } +// IsSet returns true if OptGetNftItemsByAddressesReq was set. +func (o OptGetNftItemsByAddressesReq) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptInscriptionTransferAction) Reset() { - var v InscriptionTransferAction +func (o *OptGetNftItemsByAddressesReq) Reset() { + var v GetNftItemsByAddressesReq o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptInscriptionTransferAction) SetTo(v InscriptionTransferAction) { +func (o *OptGetNftItemsByAddressesReq) SetTo(v GetNftItemsByAddressesReq) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptInscriptionTransferAction) Get() (v InscriptionTransferAction, ok bool) { +func (o OptGetNftItemsByAddressesReq) Get() (v GetNftItemsByAddressesReq, ok bool) { if !o.Set { return v, false } @@ -12268,7 +13511,7 @@ func (o OptInscriptionTransferAction) Get() (v InscriptionTransferAction, ok boo } // Or returns value if set, or given parameter if does not. -func (o OptInscriptionTransferAction) Or(d InscriptionTransferAction) InscriptionTransferAction { +func (o OptGetNftItemsByAddressesReq) Or(d GetNftItemsByAddressesReq) GetNftItemsByAddressesReq { if v, ok := o.Get(); ok { return v } @@ -12559,30 +13802,168 @@ func NewOptJettonMintAction(v JettonMintAction) OptJettonMintAction { } } -// OptJettonMintAction is optional JettonMintAction. -type OptJettonMintAction struct { - Value JettonMintAction +// OptJettonMintAction is optional JettonMintAction. +type OptJettonMintAction struct { + Value JettonMintAction + Set bool +} + +// IsSet returns true if OptJettonMintAction was set. +func (o OptJettonMintAction) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptJettonMintAction) Reset() { + var v JettonMintAction + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptJettonMintAction) SetTo(v JettonMintAction) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptJettonMintAction) Get() (v JettonMintAction, 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 OptJettonMintAction) Or(d JettonMintAction) JettonMintAction { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptJettonPreview returns new OptJettonPreview with value set to v. +func NewOptJettonPreview(v JettonPreview) OptJettonPreview { + return OptJettonPreview{ + Value: v, + Set: true, + } +} + +// OptJettonPreview is optional JettonPreview. +type OptJettonPreview struct { + Value JettonPreview + Set bool +} + +// IsSet returns true if OptJettonPreview was set. +func (o OptJettonPreview) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptJettonPreview) Reset() { + var v JettonPreview + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptJettonPreview) SetTo(v JettonPreview) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptJettonPreview) Get() (v JettonPreview, 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 OptJettonPreview) Or(d JettonPreview) JettonPreview { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptJettonSwapAction returns new OptJettonSwapAction with value set to v. +func NewOptJettonSwapAction(v JettonSwapAction) OptJettonSwapAction { + return OptJettonSwapAction{ + Value: v, + Set: true, + } +} + +// OptJettonSwapAction is optional JettonSwapAction. +type OptJettonSwapAction struct { + Value JettonSwapAction + Set bool +} + +// IsSet returns true if OptJettonSwapAction was set. +func (o OptJettonSwapAction) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptJettonSwapAction) Reset() { + var v JettonSwapAction + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptJettonSwapAction) SetTo(v JettonSwapAction) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptJettonSwapAction) Get() (v JettonSwapAction, 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 OptJettonSwapAction) Or(d JettonSwapAction) JettonSwapAction { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptJettonTransferAction returns new OptJettonTransferAction with value set to v. +func NewOptJettonTransferAction(v JettonTransferAction) OptJettonTransferAction { + return OptJettonTransferAction{ + Value: v, + Set: true, + } +} + +// OptJettonTransferAction is optional JettonTransferAction. +type OptJettonTransferAction struct { + Value JettonTransferAction Set bool } -// IsSet returns true if OptJettonMintAction was set. -func (o OptJettonMintAction) IsSet() bool { return o.Set } +// IsSet returns true if OptJettonTransferAction was set. +func (o OptJettonTransferAction) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptJettonMintAction) Reset() { - var v JettonMintAction +func (o *OptJettonTransferAction) Reset() { + var v JettonTransferAction o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptJettonMintAction) SetTo(v JettonMintAction) { +func (o *OptJettonTransferAction) SetTo(v JettonTransferAction) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptJettonMintAction) Get() (v JettonMintAction, ok bool) { +func (o OptJettonTransferAction) Get() (v JettonTransferAction, ok bool) { if !o.Set { return v, false } @@ -12590,45 +13971,45 @@ func (o OptJettonMintAction) Get() (v JettonMintAction, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptJettonMintAction) Or(d JettonMintAction) JettonMintAction { +func (o OptJettonTransferAction) Or(d JettonTransferAction) JettonTransferAction { if v, ok := o.Get(); ok { return v } return d } -// NewOptJettonPreview returns new OptJettonPreview with value set to v. -func NewOptJettonPreview(v JettonPreview) OptJettonPreview { - return OptJettonPreview{ +// NewOptLiquidityDepositAction returns new OptLiquidityDepositAction with value set to v. +func NewOptLiquidityDepositAction(v LiquidityDepositAction) OptLiquidityDepositAction { + return OptLiquidityDepositAction{ Value: v, Set: true, } } -// OptJettonPreview is optional JettonPreview. -type OptJettonPreview struct { - Value JettonPreview +// OptLiquidityDepositAction is optional LiquidityDepositAction. +type OptLiquidityDepositAction struct { + Value LiquidityDepositAction Set bool } -// IsSet returns true if OptJettonPreview was set. -func (o OptJettonPreview) IsSet() bool { return o.Set } +// IsSet returns true if OptLiquidityDepositAction was set. +func (o OptLiquidityDepositAction) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptJettonPreview) Reset() { - var v JettonPreview +func (o *OptLiquidityDepositAction) Reset() { + var v LiquidityDepositAction o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptJettonPreview) SetTo(v JettonPreview) { +func (o *OptLiquidityDepositAction) SetTo(v LiquidityDepositAction) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptJettonPreview) Get() (v JettonPreview, ok bool) { +func (o OptLiquidityDepositAction) Get() (v LiquidityDepositAction, ok bool) { if !o.Set { return v, false } @@ -12636,45 +14017,45 @@ func (o OptJettonPreview) Get() (v JettonPreview, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptJettonPreview) Or(d JettonPreview) JettonPreview { +func (o OptLiquidityDepositAction) Or(d LiquidityDepositAction) LiquidityDepositAction { if v, ok := o.Get(); ok { return v } return d } -// NewOptJettonSwapAction returns new OptJettonSwapAction with value set to v. -func NewOptJettonSwapAction(v JettonSwapAction) OptJettonSwapAction { - return OptJettonSwapAction{ +// NewOptMessage returns new OptMessage with value set to v. +func NewOptMessage(v Message) OptMessage { + return OptMessage{ Value: v, Set: true, } } -// OptJettonSwapAction is optional JettonSwapAction. -type OptJettonSwapAction struct { - Value JettonSwapAction +// OptMessage is optional Message. +type OptMessage struct { + Value Message Set bool } -// IsSet returns true if OptJettonSwapAction was set. -func (o OptJettonSwapAction) IsSet() bool { return o.Set } +// IsSet returns true if OptMessage was set. +func (o OptMessage) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptJettonSwapAction) Reset() { - var v JettonSwapAction +func (o *OptMessage) Reset() { + var v Message o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptJettonSwapAction) SetTo(v JettonSwapAction) { +func (o *OptMessage) SetTo(v Message) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptJettonSwapAction) Get() (v JettonSwapAction, ok bool) { +func (o OptMessage) Get() (v Message, ok bool) { if !o.Set { return v, false } @@ -12682,45 +14063,45 @@ func (o OptJettonSwapAction) Get() (v JettonSwapAction, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptJettonSwapAction) Or(d JettonSwapAction) JettonSwapAction { +func (o OptMessage) Or(d Message) Message { if v, ok := o.Get(); ok { return v } return d } -// NewOptJettonTransferAction returns new OptJettonTransferAction with value set to v. -func NewOptJettonTransferAction(v JettonTransferAction) OptJettonTransferAction { - return OptJettonTransferAction{ +// NewOptMessageConsequences returns new OptMessageConsequences with value set to v. +func NewOptMessageConsequences(v MessageConsequences) OptMessageConsequences { + return OptMessageConsequences{ Value: v, Set: true, } } -// OptJettonTransferAction is optional JettonTransferAction. -type OptJettonTransferAction struct { - Value JettonTransferAction +// OptMessageConsequences is optional MessageConsequences. +type OptMessageConsequences struct { + Value MessageConsequences Set bool } -// IsSet returns true if OptJettonTransferAction was set. -func (o OptJettonTransferAction) IsSet() bool { return o.Set } +// IsSet returns true if OptMessageConsequences was set. +func (o OptMessageConsequences) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptJettonTransferAction) Reset() { - var v JettonTransferAction +func (o *OptMessageConsequences) Reset() { + var v MessageConsequences o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptJettonTransferAction) SetTo(v JettonTransferAction) { +func (o *OptMessageConsequences) SetTo(v MessageConsequences) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptJettonTransferAction) Get() (v JettonTransferAction, ok bool) { +func (o OptMessageConsequences) Get() (v MessageConsequences, ok bool) { if !o.Set { return v, false } @@ -12728,45 +14109,45 @@ func (o OptJettonTransferAction) Get() (v JettonTransferAction, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptJettonTransferAction) Or(d JettonTransferAction) JettonTransferAction { +func (o OptMessageConsequences) Or(d MessageConsequences) MessageConsequences { if v, ok := o.Get(); ok { return v } return d } -// NewOptMessage returns new OptMessage with value set to v. -func NewOptMessage(v Message) OptMessage { - return OptMessage{ +// NewOptMultisigOrderChangingParameters returns new OptMultisigOrderChangingParameters with value set to v. +func NewOptMultisigOrderChangingParameters(v MultisigOrderChangingParameters) OptMultisigOrderChangingParameters { + return OptMultisigOrderChangingParameters{ Value: v, Set: true, } } -// OptMessage is optional Message. -type OptMessage struct { - Value Message +// OptMultisigOrderChangingParameters is optional MultisigOrderChangingParameters. +type OptMultisigOrderChangingParameters struct { + Value MultisigOrderChangingParameters Set bool } -// IsSet returns true if OptMessage was set. -func (o OptMessage) IsSet() bool { return o.Set } +// IsSet returns true if OptMultisigOrderChangingParameters was set. +func (o OptMultisigOrderChangingParameters) IsSet() bool { return o.Set } // Reset unsets value. -func (o *OptMessage) Reset() { - var v Message +func (o *OptMultisigOrderChangingParameters) Reset() { + var v MultisigOrderChangingParameters o.Value = v o.Set = false } // SetTo sets value to v. -func (o *OptMessage) SetTo(v Message) { +func (o *OptMultisigOrderChangingParameters) SetTo(v MultisigOrderChangingParameters) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptMessage) Get() (v Message, ok bool) { +func (o OptMultisigOrderChangingParameters) Get() (v MultisigOrderChangingParameters, ok bool) { if !o.Set { return v, false } @@ -12774,7 +14155,7 @@ func (o OptMessage) Get() (v Message, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptMessage) Or(d Message) Message { +func (o OptMultisigOrderChangingParameters) Or(d MultisigOrderChangingParameters) MultisigOrderChangingParameters { if v, ok := o.Get(); ok { return v } @@ -13011,6 +14392,98 @@ func (o OptNftPurchaseAction) Or(d NftPurchaseAction) NftPurchaseAction { return d } +// NewOptPrice returns new OptPrice with value set to v. +func NewOptPrice(v Price) OptPrice { + return OptPrice{ + Value: v, + Set: true, + } +} + +// OptPrice is optional Price. +type OptPrice struct { + Value Price + Set bool +} + +// IsSet returns true if OptPrice was set. +func (o OptPrice) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptPrice) Reset() { + var v Price + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptPrice) SetTo(v Price) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptPrice) Get() (v Price, 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 OptPrice) Or(d Price) Price { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptPurchaseAction returns new OptPurchaseAction with value set to v. +func NewOptPurchaseAction(v PurchaseAction) OptPurchaseAction { + return OptPurchaseAction{ + Value: v, + Set: true, + } +} + +// OptPurchaseAction is optional PurchaseAction. +type OptPurchaseAction struct { + Value PurchaseAction + Set bool +} + +// IsSet returns true if OptPurchaseAction was set. +func (o OptPurchaseAction) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptPurchaseAction) Reset() { + var v PurchaseAction + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptPurchaseAction) SetTo(v PurchaseAction) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptPurchaseAction) Get() (v PurchaseAction, 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 OptPurchaseAction) Or(d PurchaseAction) PurchaseAction { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptRefund returns new OptRefund with value set to v. func NewOptRefund(v Refund) OptRefund { return OptRefund{ @@ -13057,6 +14530,52 @@ func (o OptRefund) Or(d Refund) Refund { return d } +// NewOptRemoveExtensionAction returns new OptRemoveExtensionAction with value set to v. +func NewOptRemoveExtensionAction(v RemoveExtensionAction) OptRemoveExtensionAction { + return OptRemoveExtensionAction{ + Value: v, + Set: true, + } +} + +// OptRemoveExtensionAction is optional RemoveExtensionAction. +type OptRemoveExtensionAction struct { + Value RemoveExtensionAction + Set bool +} + +// IsSet returns true if OptRemoveExtensionAction was set. +func (o OptRemoveExtensionAction) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptRemoveExtensionAction) Reset() { + var v RemoveExtensionAction + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptRemoveExtensionAction) SetTo(v RemoveExtensionAction) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptRemoveExtensionAction) Get() (v RemoveExtensionAction, 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 OptRemoveExtensionAction) Or(d RemoveExtensionAction) RemoveExtensionAction { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptSale returns new OptSale with value set to v. func NewOptSale(v Sale) OptSale { return OptSale{ @@ -13082,13 +14601,105 @@ func (o *OptSale) Reset() { } // SetTo sets value to v. -func (o *OptSale) SetTo(v Sale) { +func (o *OptSale) SetTo(v Sale) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptSale) Get() (v Sale, 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 OptSale) Or(d Sale) Sale { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptSendBlockchainMessageReqMeta returns new OptSendBlockchainMessageReqMeta with value set to v. +func NewOptSendBlockchainMessageReqMeta(v SendBlockchainMessageReqMeta) OptSendBlockchainMessageReqMeta { + return OptSendBlockchainMessageReqMeta{ + Value: v, + Set: true, + } +} + +// OptSendBlockchainMessageReqMeta is optional SendBlockchainMessageReqMeta. +type OptSendBlockchainMessageReqMeta struct { + Value SendBlockchainMessageReqMeta + Set bool +} + +// IsSet returns true if OptSendBlockchainMessageReqMeta was set. +func (o OptSendBlockchainMessageReqMeta) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptSendBlockchainMessageReqMeta) Reset() { + var v SendBlockchainMessageReqMeta + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptSendBlockchainMessageReqMeta) SetTo(v SendBlockchainMessageReqMeta) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptSendBlockchainMessageReqMeta) Get() (v SendBlockchainMessageReqMeta, 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 OptSendBlockchainMessageReqMeta) Or(d SendBlockchainMessageReqMeta) SendBlockchainMessageReqMeta { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptSetSignatureAllowedAction returns new OptSetSignatureAllowedAction with value set to v. +func NewOptSetSignatureAllowedAction(v SetSignatureAllowedAction) OptSetSignatureAllowedAction { + return OptSetSignatureAllowedAction{ + Value: v, + Set: true, + } +} + +// OptSetSignatureAllowedAction is optional SetSignatureAllowedAction. +type OptSetSignatureAllowedAction struct { + Value SetSignatureAllowedAction + Set bool +} + +// IsSet returns true if OptSetSignatureAllowedAction was set. +func (o OptSetSignatureAllowedAction) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptSetSignatureAllowedAction) Reset() { + var v SetSignatureAllowedAction + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptSetSignatureAllowedAction) SetTo(v SetSignatureAllowedAction) { o.Set = true o.Value = v } // Get returns value and boolean that denotes whether value was set. -func (o OptSale) Get() (v Sale, ok bool) { +func (o OptSetSignatureAllowedAction) Get() (v SetSignatureAllowedAction, ok bool) { if !o.Set { return v, false } @@ -13096,7 +14707,7 @@ func (o OptSale) Get() (v Sale, ok bool) { } // Or returns value if set, or given parameter if does not. -func (o OptSale) Or(d Sale) Sale { +func (o OptSetSignatureAllowedAction) Or(d SetSignatureAllowedAction) SetSignatureAllowedAction { if v, ok := o.Get(); ok { return v } @@ -13149,6 +14760,52 @@ func (o OptSmartContractAction) Or(d SmartContractAction) SmartContractAction { return d } +// NewOptSource returns new OptSource with value set to v. +func NewOptSource(v Source) OptSource { + return OptSource{ + Value: v, + Set: true, + } +} + +// OptSource is optional Source. +type OptSource struct { + Value Source + Set bool +} + +// IsSet returns true if OptSource was set. +func (o OptSource) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptSource) Reset() { + var v Source + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptSource) SetTo(v Source) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptSource) Get() (v Source, 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 OptSource) Or(d Source) Source { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptStateInit returns new OptStateInit with value set to v. func NewOptStateInit(v StateInit) OptStateInit { return OptStateInit{ @@ -13839,6 +15496,52 @@ func (o OptWithdrawStakeRequestAction) Or(d WithdrawStakeRequestAction) Withdraw return d } +// NewOptWithdrawTokenStakeRequestAction returns new OptWithdrawTokenStakeRequestAction with value set to v. +func NewOptWithdrawTokenStakeRequestAction(v WithdrawTokenStakeRequestAction) OptWithdrawTokenStakeRequestAction { + return OptWithdrawTokenStakeRequestAction{ + Value: v, + Set: true, + } +} + +// OptWithdrawTokenStakeRequestAction is optional WithdrawTokenStakeRequestAction. +type OptWithdrawTokenStakeRequestAction struct { + Value WithdrawTokenStakeRequestAction + Set bool +} + +// IsSet returns true if OptWithdrawTokenStakeRequestAction was set. +func (o OptWithdrawTokenStakeRequestAction) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptWithdrawTokenStakeRequestAction) Reset() { + var v WithdrawTokenStakeRequestAction + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptWithdrawTokenStakeRequestAction) SetTo(v WithdrawTokenStakeRequestAction) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptWithdrawTokenStakeRequestAction) Get() (v WithdrawTokenStakeRequestAction, 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 OptWithdrawTokenStakeRequestAction) Or(d WithdrawTokenStakeRequestAction) WithdrawTokenStakeRequestAction { + if v, ok := o.Get(); ok { + return v + } + return d +} + // Ref: #/components/schemas/Oracle type Oracle struct { Address string `json:"address"` @@ -14083,135 +15786,367 @@ func (s *PoolInfo) GetVerified() bool { return s.Verified } -// GetCurrentNominators returns the value of CurrentNominators. -func (s *PoolInfo) GetCurrentNominators() int { - return s.CurrentNominators +// GetCurrentNominators returns the value of CurrentNominators. +func (s *PoolInfo) GetCurrentNominators() int { + return s.CurrentNominators +} + +// GetMaxNominators returns the value of MaxNominators. +func (s *PoolInfo) GetMaxNominators() int { + return s.MaxNominators +} + +// GetLiquidJettonMaster returns the value of LiquidJettonMaster. +func (s *PoolInfo) GetLiquidJettonMaster() OptString { + return s.LiquidJettonMaster +} + +// GetNominatorsStake returns the value of NominatorsStake. +func (s *PoolInfo) GetNominatorsStake() int64 { + return s.NominatorsStake +} + +// GetValidatorStake returns the value of ValidatorStake. +func (s *PoolInfo) GetValidatorStake() int64 { + return s.ValidatorStake +} + +// GetCycleLength returns the value of CycleLength. +func (s *PoolInfo) GetCycleLength() OptInt64 { + return s.CycleLength +} + +// SetAddress sets the value of Address. +func (s *PoolInfo) SetAddress(val string) { + s.Address = val +} + +// SetName sets the value of Name. +func (s *PoolInfo) SetName(val string) { + s.Name = val +} + +// SetTotalAmount sets the value of TotalAmount. +func (s *PoolInfo) SetTotalAmount(val int64) { + s.TotalAmount = val +} + +// SetImplementation sets the value of Implementation. +func (s *PoolInfo) SetImplementation(val PoolImplementationType) { + s.Implementation = val +} + +// SetApy sets the value of Apy. +func (s *PoolInfo) SetApy(val float64) { + s.Apy = val +} + +// SetMinStake sets the value of MinStake. +func (s *PoolInfo) SetMinStake(val int64) { + s.MinStake = val +} + +// SetCycleStart sets the value of CycleStart. +func (s *PoolInfo) SetCycleStart(val int64) { + s.CycleStart = val +} + +// SetCycleEnd sets the value of CycleEnd. +func (s *PoolInfo) SetCycleEnd(val int64) { + s.CycleEnd = val +} + +// SetVerified sets the value of Verified. +func (s *PoolInfo) SetVerified(val bool) { + s.Verified = val +} + +// SetCurrentNominators sets the value of CurrentNominators. +func (s *PoolInfo) SetCurrentNominators(val int) { + s.CurrentNominators = val +} + +// SetMaxNominators sets the value of MaxNominators. +func (s *PoolInfo) SetMaxNominators(val int) { + s.MaxNominators = val +} + +// SetLiquidJettonMaster sets the value of LiquidJettonMaster. +func (s *PoolInfo) SetLiquidJettonMaster(val OptString) { + s.LiquidJettonMaster = val +} + +// SetNominatorsStake sets the value of NominatorsStake. +func (s *PoolInfo) SetNominatorsStake(val int64) { + s.NominatorsStake = val +} + +// SetValidatorStake sets the value of ValidatorStake. +func (s *PoolInfo) SetValidatorStake(val int64) { + s.ValidatorStake = val +} + +// SetCycleLength sets the value of CycleLength. +func (s *PoolInfo) SetCycleLength(val OptInt64) { + s.CycleLength = val +} + +// Ref: #/components/schemas/Price +type Price struct { + CurrencyType CurrencyType `json:"currency_type"` + Value string `json:"value"` + Decimals int `json:"decimals"` + TokenName string `json:"token_name"` + Verification TrustType `json:"verification"` + Image string `json:"image"` + Jetton OptString `json:"jetton"` +} + +// GetCurrencyType returns the value of CurrencyType. +func (s *Price) GetCurrencyType() CurrencyType { + return s.CurrencyType +} + +// GetValue returns the value of Value. +func (s *Price) GetValue() string { + return s.Value +} + +// GetDecimals returns the value of Decimals. +func (s *Price) GetDecimals() int { + return s.Decimals +} + +// GetTokenName returns the value of TokenName. +func (s *Price) GetTokenName() string { + return s.TokenName +} + +// GetVerification returns the value of Verification. +func (s *Price) GetVerification() TrustType { + return s.Verification +} + +// GetImage returns the value of Image. +func (s *Price) GetImage() string { + return s.Image +} + +// GetJetton returns the value of Jetton. +func (s *Price) GetJetton() OptString { + return s.Jetton +} + +// SetCurrencyType sets the value of CurrencyType. +func (s *Price) SetCurrencyType(val CurrencyType) { + s.CurrencyType = val +} + +// SetValue sets the value of Value. +func (s *Price) SetValue(val string) { + s.Value = val +} + +// SetDecimals sets the value of Decimals. +func (s *Price) SetDecimals(val int) { + s.Decimals = val +} + +// SetTokenName sets the value of TokenName. +func (s *Price) SetTokenName(val string) { + s.TokenName = val +} + +// SetVerification sets the value of Verification. +func (s *Price) SetVerification(val TrustType) { + s.Verification = val +} + +// SetImage sets the value of Image. +func (s *Price) SetImage(val string) { + s.Image = val +} + +// SetJetton sets the value of Jetton. +func (s *Price) SetJetton(val OptString) { + s.Jetton = val +} + +// Ref: #/components/schemas/Protocol +type Protocol struct { + Name string `json:"name"` + Image OptString `json:"image"` +} + +// GetName returns the value of Name. +func (s *Protocol) GetName() string { + return s.Name +} + +// GetImage returns the value of Image. +func (s *Protocol) GetImage() OptString { + return s.Image +} + +// SetName sets the value of Name. +func (s *Protocol) SetName(val string) { + s.Name = val +} + +// SetImage sets the value of Image. +func (s *Protocol) SetImage(val OptString) { + s.Image = val +} + +// Ref: #/components/schemas/Purchase +type Purchase struct { + EventID string `json:"event_id"` + InvoiceID string `json:"invoice_id"` + Source AccountAddress `json:"source"` + Destination AccountAddress `json:"destination"` + Lt int64 `json:"lt"` + Utime int64 `json:"utime"` + Amount Price `json:"amount"` + Metadata Metadata `json:"metadata"` +} + +// GetEventID returns the value of EventID. +func (s *Purchase) GetEventID() string { + return s.EventID +} + +// GetInvoiceID returns the value of InvoiceID. +func (s *Purchase) GetInvoiceID() string { + return s.InvoiceID } -// GetMaxNominators returns the value of MaxNominators. -func (s *PoolInfo) GetMaxNominators() int { - return s.MaxNominators +// GetSource returns the value of Source. +func (s *Purchase) GetSource() AccountAddress { + return s.Source } -// GetLiquidJettonMaster returns the value of LiquidJettonMaster. -func (s *PoolInfo) GetLiquidJettonMaster() OptString { - return s.LiquidJettonMaster +// GetDestination returns the value of Destination. +func (s *Purchase) GetDestination() AccountAddress { + return s.Destination } -// GetNominatorsStake returns the value of NominatorsStake. -func (s *PoolInfo) GetNominatorsStake() int64 { - return s.NominatorsStake +// GetLt returns the value of Lt. +func (s *Purchase) GetLt() int64 { + return s.Lt } -// GetValidatorStake returns the value of ValidatorStake. -func (s *PoolInfo) GetValidatorStake() int64 { - return s.ValidatorStake +// GetUtime returns the value of Utime. +func (s *Purchase) GetUtime() int64 { + return s.Utime } -// GetCycleLength returns the value of CycleLength. -func (s *PoolInfo) GetCycleLength() OptInt64 { - return s.CycleLength +// GetAmount returns the value of Amount. +func (s *Purchase) GetAmount() Price { + return s.Amount } -// SetAddress sets the value of Address. -func (s *PoolInfo) SetAddress(val string) { - s.Address = val +// GetMetadata returns the value of Metadata. +func (s *Purchase) GetMetadata() Metadata { + return s.Metadata } -// SetName sets the value of Name. -func (s *PoolInfo) SetName(val string) { - s.Name = val +// SetEventID sets the value of EventID. +func (s *Purchase) SetEventID(val string) { + s.EventID = val } -// SetTotalAmount sets the value of TotalAmount. -func (s *PoolInfo) SetTotalAmount(val int64) { - s.TotalAmount = val +// SetInvoiceID sets the value of InvoiceID. +func (s *Purchase) SetInvoiceID(val string) { + s.InvoiceID = val } -// SetImplementation sets the value of Implementation. -func (s *PoolInfo) SetImplementation(val PoolImplementationType) { - s.Implementation = val +// SetSource sets the value of Source. +func (s *Purchase) SetSource(val AccountAddress) { + s.Source = val } -// SetApy sets the value of Apy. -func (s *PoolInfo) SetApy(val float64) { - s.Apy = val +// SetDestination sets the value of Destination. +func (s *Purchase) SetDestination(val AccountAddress) { + s.Destination = val } -// SetMinStake sets the value of MinStake. -func (s *PoolInfo) SetMinStake(val int64) { - s.MinStake = val +// SetLt sets the value of Lt. +func (s *Purchase) SetLt(val int64) { + s.Lt = val } -// SetCycleStart sets the value of CycleStart. -func (s *PoolInfo) SetCycleStart(val int64) { - s.CycleStart = val +// SetUtime sets the value of Utime. +func (s *Purchase) SetUtime(val int64) { + s.Utime = val } -// SetCycleEnd sets the value of CycleEnd. -func (s *PoolInfo) SetCycleEnd(val int64) { - s.CycleEnd = val +// SetAmount sets the value of Amount. +func (s *Purchase) SetAmount(val Price) { + s.Amount = val } -// SetVerified sets the value of Verified. -func (s *PoolInfo) SetVerified(val bool) { - s.Verified = val +// SetMetadata sets the value of Metadata. +func (s *Purchase) SetMetadata(val Metadata) { + s.Metadata = val } -// SetCurrentNominators sets the value of CurrentNominators. -func (s *PoolInfo) SetCurrentNominators(val int) { - s.CurrentNominators = val +// Ref: #/components/schemas/PurchaseAction +type PurchaseAction struct { + Source AccountAddress `json:"source"` + Destination AccountAddress `json:"destination"` + InvoiceID string `json:"invoice_id"` + Amount Price `json:"amount"` + Metadata Metadata `json:"metadata"` } -// SetMaxNominators sets the value of MaxNominators. -func (s *PoolInfo) SetMaxNominators(val int) { - s.MaxNominators = val +// GetSource returns the value of Source. +func (s *PurchaseAction) GetSource() AccountAddress { + return s.Source } -// SetLiquidJettonMaster sets the value of LiquidJettonMaster. -func (s *PoolInfo) SetLiquidJettonMaster(val OptString) { - s.LiquidJettonMaster = val +// GetDestination returns the value of Destination. +func (s *PurchaseAction) GetDestination() AccountAddress { + return s.Destination } -// SetNominatorsStake sets the value of NominatorsStake. -func (s *PoolInfo) SetNominatorsStake(val int64) { - s.NominatorsStake = val +// GetInvoiceID returns the value of InvoiceID. +func (s *PurchaseAction) GetInvoiceID() string { + return s.InvoiceID } -// SetValidatorStake sets the value of ValidatorStake. -func (s *PoolInfo) SetValidatorStake(val int64) { - s.ValidatorStake = val +// GetAmount returns the value of Amount. +func (s *PurchaseAction) GetAmount() Price { + return s.Amount } -// SetCycleLength sets the value of CycleLength. -func (s *PoolInfo) SetCycleLength(val OptInt64) { - s.CycleLength = val +// GetMetadata returns the value of Metadata. +func (s *PurchaseAction) GetMetadata() Metadata { + return s.Metadata } -// Ref: #/components/schemas/Price -type Price struct { - Value string `json:"value"` - TokenName string `json:"token_name"` +// SetSource sets the value of Source. +func (s *PurchaseAction) SetSource(val AccountAddress) { + s.Source = val } -// GetValue returns the value of Value. -func (s *Price) GetValue() string { - return s.Value +// SetDestination sets the value of Destination. +func (s *PurchaseAction) SetDestination(val AccountAddress) { + s.Destination = val } -// GetTokenName returns the value of TokenName. -func (s *Price) GetTokenName() string { - return s.TokenName +// SetInvoiceID sets the value of InvoiceID. +func (s *PurchaseAction) SetInvoiceID(val string) { + s.InvoiceID = val } -// SetValue sets the value of Value. -func (s *Price) SetValue(val string) { - s.Value = val +// SetAmount sets the value of Amount. +func (s *PurchaseAction) SetAmount(val Price) { + s.Amount = val } -// SetTokenName sets the value of TokenName. -func (s *Price) SetTokenName(val string) { - s.TokenName = val +// SetMetadata sets the value of Metadata. +func (s *PurchaseAction) SetMetadata(val Metadata) { + s.Metadata = val } // Ref: #/components/schemas/RawBlockchainConfig @@ -14424,6 +16359,32 @@ func (s *RefundType) UnmarshalText(data []byte) error { // ReindexAccountOK is response for ReindexAccount operation. type ReindexAccountOK struct{} +// Ref: #/components/schemas/RemoveExtensionAction +type RemoveExtensionAction struct { + Wallet AccountAddress `json:"wallet"` + Extension string `json:"extension"` +} + +// GetWallet returns the value of Wallet. +func (s *RemoveExtensionAction) GetWallet() AccountAddress { + return s.Wallet +} + +// GetExtension returns the value of Extension. +func (s *RemoveExtensionAction) GetExtension() string { + return s.Extension +} + +// SetWallet sets the value of Wallet. +func (s *RemoveExtensionAction) SetWallet(val AccountAddress) { + s.Wallet = val +} + +// SetExtension sets the value of Extension. +func (s *RemoveExtensionAction) SetExtension(val string) { + s.Extension = val +} + // Risk specifies assets that could be lost if a message would be sent to a malicious smart contract. // It makes sense to understand the risk BEFORE sending a message to the blockchain. // Ref: #/components/schemas/Risk @@ -14433,6 +16394,8 @@ type Risk struct { Ton int64 `json:"ton"` Jettons []JettonQuantity `json:"jettons"` Nfts []NftItem `json:"nfts"` + // Estimated equivalent value of all assets at risk in selected currency (for example USD). + TotalEquivalent OptFloat32 `json:"total_equivalent"` } // GetTransferAllRemainingBalance returns the value of TransferAllRemainingBalance. @@ -14455,6 +16418,11 @@ func (s *Risk) GetNfts() []NftItem { return s.Nfts } +// GetTotalEquivalent returns the value of TotalEquivalent. +func (s *Risk) GetTotalEquivalent() OptFloat32 { + return s.TotalEquivalent +} + // SetTransferAllRemainingBalance sets the value of TransferAllRemainingBalance. func (s *Risk) SetTransferAllRemainingBalance(val bool) { s.TransferAllRemainingBalance = val @@ -14475,6 +16443,11 @@ func (s *Risk) SetNfts(val []NftItem) { s.Nfts = val } +// SetTotalEquivalent sets the value of TotalEquivalent. +func (s *Risk) SetTotalEquivalent(val OptFloat32) { + s.TotalEquivalent = val +} + // Ref: #/components/schemas/Sale type Sale struct { Address string `json:"address"` @@ -14527,8 +16500,9 @@ func (s *Sale) SetPrice(val Price) { type SendBlockchainMessageOK struct{} type SendBlockchainMessageReq struct { - Boc OptString `json:"boc"` - Batch []string `json:"batch"` + Boc OptString `json:"boc"` + Batch []string `json:"batch"` + Meta OptSendBlockchainMessageReqMeta `json:"meta"` } // GetBoc returns the value of Boc. @@ -14541,6 +16515,11 @@ func (s *SendBlockchainMessageReq) GetBatch() []string { return s.Batch } +// GetMeta returns the value of Meta. +func (s *SendBlockchainMessageReq) GetMeta() OptSendBlockchainMessageReqMeta { + return s.Meta +} + // SetBoc sets the value of Boc. func (s *SendBlockchainMessageReq) SetBoc(val OptString) { s.Boc = val @@ -14551,6 +16530,22 @@ func (s *SendBlockchainMessageReq) SetBatch(val []string) { s.Batch = val } +// SetMeta sets the value of Meta. +func (s *SendBlockchainMessageReq) SetMeta(val OptSendBlockchainMessageReqMeta) { + s.Meta = val +} + +type SendBlockchainMessageReqMeta map[string]string + +func (s *SendBlockchainMessageReqMeta) init() SendBlockchainMessageReqMeta { + m := *s + if m == nil { + m = map[string]string{} + *s = m + } + return m +} + type SendRawMessageOK struct { Code int32 `json:"code"` } @@ -14631,21 +16626,30 @@ func (s *ServiceStatus) SetLastKnownMasterchainSeqno(val int32) { s.LastKnownMasterchainSeqno = val } -// SetWalletBackupOK is response for SetWalletBackup operation. -type SetWalletBackupOK struct{} +// Ref: #/components/schemas/SetSignatureAllowedAction +type SetSignatureAllowedAction struct { + Wallet AccountAddress `json:"wallet"` + Allowed bool `json:"allowed"` +} -type SetWalletBackupReq struct { - Data io.Reader +// GetWallet returns the value of Wallet. +func (s *SetSignatureAllowedAction) GetWallet() AccountAddress { + return s.Wallet } -// Read reads data from the Data reader. -// -// Kept to satisfy the io.Reader interface. -func (s SetWalletBackupReq) Read(p []byte) (n int, err error) { - if s.Data == nil { - return 0, io.EOF - } - return s.Data.Read(p) +// GetAllowed returns the value of Allowed. +func (s *SetSignatureAllowedAction) GetAllowed() bool { + return s.Allowed +} + +// SetWallet sets the value of Wallet. +func (s *SetSignatureAllowedAction) SetWallet(val AccountAddress) { + s.Wallet = val +} + +// SetAllowed sets the value of Allowed. +func (s *SetSignatureAllowedAction) SetAllowed(val bool) { + s.Allowed = val } // Ref: #/components/schemas/SignRawMessage @@ -14701,12 +16705,19 @@ func (s *SignRawMessage) SetStateInit(val OptString) { // Ref: #/components/schemas/SignRawParams type SignRawParams struct { + ProtocolName string `json:"protocol_name"` RelayAddress string `json:"relay_address"` // Commission for the transaction. In nanocoins. - Commission string `json:"commission"` - From string `json:"from"` - ValidUntil int64 `json:"valid_until"` - Messages []SignRawMessage `json:"messages"` + Commission string `json:"commission"` + From string `json:"from"` + ValidUntil int64 `json:"valid_until"` + Messages []SignRawMessage `json:"messages"` + Emulation OptMessageConsequences `json:"emulation"` +} + +// GetProtocolName returns the value of ProtocolName. +func (s *SignRawParams) GetProtocolName() string { + return s.ProtocolName } // GetRelayAddress returns the value of RelayAddress. @@ -14734,6 +16745,16 @@ func (s *SignRawParams) GetMessages() []SignRawMessage { return s.Messages } +// GetEmulation returns the value of Emulation. +func (s *SignRawParams) GetEmulation() OptMessageConsequences { + return s.Emulation +} + +// SetProtocolName sets the value of ProtocolName. +func (s *SignRawParams) SetProtocolName(val string) { + s.ProtocolName = val +} + // SetRelayAddress sets the value of RelayAddress. func (s *SignRawParams) SetRelayAddress(val string) { s.RelayAddress = val @@ -14759,6 +16780,11 @@ func (s *SignRawParams) SetMessages(val []SignRawMessage) { s.Messages = val } +// SetEmulation sets the value of Emulation. +func (s *SignRawParams) SetEmulation(val OptMessageConsequences) { + s.Emulation = val +} + // Ref: #/components/schemas/SizeLimitsConfig type SizeLimitsConfig struct { MaxMsgBits int64 `json:"max_msg_bits"` @@ -14922,6 +16948,80 @@ func (s *SmartContractAction) SetRefund(val OptRefund) { s.Refund = val } +// Ref: #/components/schemas/Source +type Source struct { + Files []SourceFile `json:"files"` +} + +// GetFiles returns the value of Files. +func (s *Source) GetFiles() []SourceFile { + return s.Files +} + +// SetFiles sets the value of Files. +func (s *Source) SetFiles(val []SourceFile) { + s.Files = val +} + +// Ref: #/components/schemas/SourceFile +type SourceFile struct { + Name string `json:"name"` + Content string `json:"content"` + IsEntrypoint bool `json:"is_entrypoint"` + IsStdLib bool `json:"is_std_lib"` + IncludeInCommand bool `json:"include_in_command"` +} + +// GetName returns the value of Name. +func (s *SourceFile) GetName() string { + return s.Name +} + +// GetContent returns the value of Content. +func (s *SourceFile) GetContent() string { + return s.Content +} + +// GetIsEntrypoint returns the value of IsEntrypoint. +func (s *SourceFile) GetIsEntrypoint() bool { + return s.IsEntrypoint +} + +// GetIsStdLib returns the value of IsStdLib. +func (s *SourceFile) GetIsStdLib() bool { + return s.IsStdLib +} + +// GetIncludeInCommand returns the value of IncludeInCommand. +func (s *SourceFile) GetIncludeInCommand() bool { + return s.IncludeInCommand +} + +// SetName sets the value of Name. +func (s *SourceFile) SetName(val string) { + s.Name = val +} + +// SetContent sets the value of Content. +func (s *SourceFile) SetContent(val string) { + s.Content = val +} + +// SetIsEntrypoint sets the value of IsEntrypoint. +func (s *SourceFile) SetIsEntrypoint(val bool) { + s.IsEntrypoint = val +} + +// SetIsStdLib sets the value of IsStdLib. +func (s *SourceFile) SetIsStdLib(val bool) { + s.IsStdLib = val +} + +// SetIncludeInCommand sets the value of IncludeInCommand. +func (s *SourceFile) SetIncludeInCommand(val bool) { + s.IncludeInCommand = val +} + // Ref: #/components/schemas/StateInit type StateInit struct { Boc string `json:"boc"` @@ -15057,127 +17157,130 @@ func (s *StorageProvider) SetMaximalFileSize(val int64) { // Ref: #/components/schemas/Subscription type Subscription struct { - Address string `json:"address"` - WalletAddress string `json:"wallet_address"` - BeneficiaryAddress string `json:"beneficiary_address"` - Amount int64 `json:"amount"` - Period int64 `json:"period"` - StartTime int64 `json:"start_time"` - Timeout int64 `json:"timeout"` - LastPaymentTime int64 `json:"last_payment_time"` - LastRequestTime int64 `json:"last_request_time"` - SubscriptionID int64 `json:"subscription_id"` - FailedAttempts int32 `json:"failed_attempts"` + // Type of subscription. + Type string `json:"type"` + Status SubscriptionStatus `json:"status"` + // Payment period in seconds. + Period int64 `json:"period"` + // Common identifier. + SubscriptionID string `json:"subscription_id"` + PaymentPerPeriod Price `json:"payment_per_period"` + Wallet AccountAddress `json:"wallet"` + NextChargeAt int64 `json:"next_charge_at"` + Metadata Metadata `json:"metadata"` + Address OptString `json:"address"` + Beneficiary OptAccountAddress `json:"beneficiary"` + Admin OptAccountAddress `json:"admin"` } -// GetAddress returns the value of Address. -func (s *Subscription) GetAddress() string { - return s.Address +// GetType returns the value of Type. +func (s *Subscription) GetType() string { + return s.Type } -// GetWalletAddress returns the value of WalletAddress. -func (s *Subscription) GetWalletAddress() string { - return s.WalletAddress +// GetStatus returns the value of Status. +func (s *Subscription) GetStatus() SubscriptionStatus { + return s.Status } -// GetBeneficiaryAddress returns the value of BeneficiaryAddress. -func (s *Subscription) GetBeneficiaryAddress() string { - return s.BeneficiaryAddress +// GetPeriod returns the value of Period. +func (s *Subscription) GetPeriod() int64 { + return s.Period } -// GetAmount returns the value of Amount. -func (s *Subscription) GetAmount() int64 { - return s.Amount +// GetSubscriptionID returns the value of SubscriptionID. +func (s *Subscription) GetSubscriptionID() string { + return s.SubscriptionID } -// GetPeriod returns the value of Period. -func (s *Subscription) GetPeriod() int64 { - return s.Period +// GetPaymentPerPeriod returns the value of PaymentPerPeriod. +func (s *Subscription) GetPaymentPerPeriod() Price { + return s.PaymentPerPeriod } -// GetStartTime returns the value of StartTime. -func (s *Subscription) GetStartTime() int64 { - return s.StartTime +// GetWallet returns the value of Wallet. +func (s *Subscription) GetWallet() AccountAddress { + return s.Wallet } -// GetTimeout returns the value of Timeout. -func (s *Subscription) GetTimeout() int64 { - return s.Timeout +// GetNextChargeAt returns the value of NextChargeAt. +func (s *Subscription) GetNextChargeAt() int64 { + return s.NextChargeAt } -// GetLastPaymentTime returns the value of LastPaymentTime. -func (s *Subscription) GetLastPaymentTime() int64 { - return s.LastPaymentTime +// GetMetadata returns the value of Metadata. +func (s *Subscription) GetMetadata() Metadata { + return s.Metadata } -// GetLastRequestTime returns the value of LastRequestTime. -func (s *Subscription) GetLastRequestTime() int64 { - return s.LastRequestTime +// GetAddress returns the value of Address. +func (s *Subscription) GetAddress() OptString { + return s.Address } -// GetSubscriptionID returns the value of SubscriptionID. -func (s *Subscription) GetSubscriptionID() int64 { - return s.SubscriptionID +// GetBeneficiary returns the value of Beneficiary. +func (s *Subscription) GetBeneficiary() OptAccountAddress { + return s.Beneficiary } -// GetFailedAttempts returns the value of FailedAttempts. -func (s *Subscription) GetFailedAttempts() int32 { - return s.FailedAttempts +// GetAdmin returns the value of Admin. +func (s *Subscription) GetAdmin() OptAccountAddress { + return s.Admin } -// SetAddress sets the value of Address. -func (s *Subscription) SetAddress(val string) { - s.Address = val +// SetType sets the value of Type. +func (s *Subscription) SetType(val string) { + s.Type = val } -// SetWalletAddress sets the value of WalletAddress. -func (s *Subscription) SetWalletAddress(val string) { - s.WalletAddress = val +// SetStatus sets the value of Status. +func (s *Subscription) SetStatus(val SubscriptionStatus) { + s.Status = val } -// SetBeneficiaryAddress sets the value of BeneficiaryAddress. -func (s *Subscription) SetBeneficiaryAddress(val string) { - s.BeneficiaryAddress = val +// SetPeriod sets the value of Period. +func (s *Subscription) SetPeriod(val int64) { + s.Period = val } -// SetAmount sets the value of Amount. -func (s *Subscription) SetAmount(val int64) { - s.Amount = val +// SetSubscriptionID sets the value of SubscriptionID. +func (s *Subscription) SetSubscriptionID(val string) { + s.SubscriptionID = val } -// SetPeriod sets the value of Period. -func (s *Subscription) SetPeriod(val int64) { - s.Period = val +// SetPaymentPerPeriod sets the value of PaymentPerPeriod. +func (s *Subscription) SetPaymentPerPeriod(val Price) { + s.PaymentPerPeriod = val } -// SetStartTime sets the value of StartTime. -func (s *Subscription) SetStartTime(val int64) { - s.StartTime = val +// SetWallet sets the value of Wallet. +func (s *Subscription) SetWallet(val AccountAddress) { + s.Wallet = val } -// SetTimeout sets the value of Timeout. -func (s *Subscription) SetTimeout(val int64) { - s.Timeout = val +// SetNextChargeAt sets the value of NextChargeAt. +func (s *Subscription) SetNextChargeAt(val int64) { + s.NextChargeAt = val } -// SetLastPaymentTime sets the value of LastPaymentTime. -func (s *Subscription) SetLastPaymentTime(val int64) { - s.LastPaymentTime = val +// SetMetadata sets the value of Metadata. +func (s *Subscription) SetMetadata(val Metadata) { + s.Metadata = val } -// SetLastRequestTime sets the value of LastRequestTime. -func (s *Subscription) SetLastRequestTime(val int64) { - s.LastRequestTime = val +// SetAddress sets the value of Address. +func (s *Subscription) SetAddress(val OptString) { + s.Address = val } -// SetSubscriptionID sets the value of SubscriptionID. -func (s *Subscription) SetSubscriptionID(val int64) { - s.SubscriptionID = val +// SetBeneficiary sets the value of Beneficiary. +func (s *Subscription) SetBeneficiary(val OptAccountAddress) { + s.Beneficiary = val } -// SetFailedAttempts sets the value of FailedAttempts. -func (s *Subscription) SetFailedAttempts(val int32) { - s.FailedAttempts = val +// SetAdmin sets the value of Admin. +func (s *Subscription) SetAdmin(val OptAccountAddress) { + s.Admin = val } // Ref: #/components/schemas/SubscriptionAction @@ -15185,8 +17288,11 @@ type SubscriptionAction struct { Subscriber AccountAddress `json:"subscriber"` Subscription string `json:"subscription"` Beneficiary AccountAddress `json:"beneficiary"` - Amount int64 `json:"amount"` - Initial bool `json:"initial"` + Admin AccountAddress `json:"admin"` + // Deprecated: schema marks this property as deprecated. + Amount OptInt64 `json:"amount"` + Price Price `json:"price"` + Initial bool `json:"initial"` } // GetSubscriber returns the value of Subscriber. @@ -15204,11 +17310,21 @@ func (s *SubscriptionAction) GetBeneficiary() AccountAddress { return s.Beneficiary } +// GetAdmin returns the value of Admin. +func (s *SubscriptionAction) GetAdmin() AccountAddress { + return s.Admin +} + // GetAmount returns the value of Amount. -func (s *SubscriptionAction) GetAmount() int64 { +func (s *SubscriptionAction) GetAmount() OptInt64 { return s.Amount } +// GetPrice returns the value of Price. +func (s *SubscriptionAction) GetPrice() Price { + return s.Price +} + // GetInitial returns the value of Initial. func (s *SubscriptionAction) GetInitial() bool { return s.Initial @@ -15229,16 +17345,81 @@ func (s *SubscriptionAction) SetBeneficiary(val AccountAddress) { s.Beneficiary = val } +// SetAdmin sets the value of Admin. +func (s *SubscriptionAction) SetAdmin(val AccountAddress) { + s.Admin = val +} + // SetAmount sets the value of Amount. -func (s *SubscriptionAction) SetAmount(val int64) { +func (s *SubscriptionAction) SetAmount(val OptInt64) { s.Amount = val } +// SetPrice sets the value of Price. +func (s *SubscriptionAction) SetPrice(val Price) { + s.Price = val +} + // SetInitial sets the value of Initial. func (s *SubscriptionAction) SetInitial(val bool) { s.Initial = val } +type SubscriptionStatus string + +const ( + SubscriptionStatusNotReady SubscriptionStatus = "not_ready" + SubscriptionStatusActive SubscriptionStatus = "active" + SubscriptionStatusSuspended SubscriptionStatus = "suspended" + SubscriptionStatusCancelled SubscriptionStatus = "cancelled" +) + +// AllValues returns all SubscriptionStatus values. +func (SubscriptionStatus) AllValues() []SubscriptionStatus { + return []SubscriptionStatus{ + SubscriptionStatusNotReady, + SubscriptionStatusActive, + SubscriptionStatusSuspended, + SubscriptionStatusCancelled, + } +} + +// MarshalText implements encoding.TextMarshaler. +func (s SubscriptionStatus) MarshalText() ([]byte, error) { + switch s { + case SubscriptionStatusNotReady: + return []byte(s), nil + case SubscriptionStatusActive: + return []byte(s), nil + case SubscriptionStatusSuspended: + return []byte(s), nil + case SubscriptionStatusCancelled: + return []byte(s), nil + default: + return nil, errors.Errorf("invalid value: %q", s) + } +} + +// UnmarshalText implements encoding.TextUnmarshaler. +func (s *SubscriptionStatus) UnmarshalText(data []byte) error { + switch SubscriptionStatus(data) { + case SubscriptionStatusNotReady: + *s = SubscriptionStatusNotReady + return nil + case SubscriptionStatusActive: + *s = SubscriptionStatusActive + return nil + case SubscriptionStatusSuspended: + *s = SubscriptionStatusSuspended + return nil + case SubscriptionStatusCancelled: + *s = SubscriptionStatusCancelled + return nil + default: + return errors.Errorf("invalid value: %q", data) + } +} + // Ref: #/components/schemas/Subscriptions type Subscriptions struct { Subscriptions []Subscription `json:"subscriptions"` @@ -16182,6 +18363,7 @@ type UnSubscriptionAction struct { Subscriber AccountAddress `json:"subscriber"` Subscription string `json:"subscription"` Beneficiary AccountAddress `json:"beneficiary"` + Admin AccountAddress `json:"admin"` } // GetSubscriber returns the value of Subscriber. @@ -16199,6 +18381,11 @@ func (s *UnSubscriptionAction) GetBeneficiary() AccountAddress { return s.Beneficiary } +// GetAdmin returns the value of Admin. +func (s *UnSubscriptionAction) GetAdmin() AccountAddress { + return s.Admin +} + // SetSubscriber sets the value of Subscriber. func (s *UnSubscriptionAction) SetSubscriber(val AccountAddress) { s.Subscriber = val @@ -16214,6 +18401,11 @@ func (s *UnSubscriptionAction) SetBeneficiary(val AccountAddress) { s.Beneficiary = val } +// SetAdmin sets the value of Admin. +func (s *UnSubscriptionAction) SetAdmin(val AccountAddress) { + s.Admin = val +} + // Ref: #/components/schemas/Validator type Validator struct { Address string `json:"address"` @@ -16476,9 +18668,11 @@ func (s *ValueFlow) SetJettons(val []ValueFlowJettonsItem) { } type ValueFlowJettonsItem struct { - Account AccountAddress `json:"account"` - Jetton JettonPreview `json:"jetton"` - Quantity int64 `json:"quantity"` + Account AccountAddress `json:"account"` + Jetton JettonPreview `json:"jetton"` + Qty string `json:"qty"` + // Deprecated: schema marks this property as deprecated. + Quantity int64 `json:"quantity"` } // GetAccount returns the value of Account. @@ -16491,6 +18685,11 @@ func (s *ValueFlowJettonsItem) GetJetton() JettonPreview { return s.Jetton } +// GetQty returns the value of Qty. +func (s *ValueFlowJettonsItem) GetQty() string { + return s.Qty +} + // GetQuantity returns the value of Quantity. func (s *ValueFlowJettonsItem) GetQuantity() int64 { return s.Quantity @@ -16506,11 +18705,202 @@ func (s *ValueFlowJettonsItem) SetJetton(val JettonPreview) { s.Jetton = val } +// SetQty sets the value of Qty. +func (s *ValueFlowJettonsItem) SetQty(val string) { + s.Qty = val +} + // SetQuantity sets the value of Quantity. func (s *ValueFlowJettonsItem) SetQuantity(val int64) { s.Quantity = val } +// Ref: #/components/schemas/VaultDepositInfo +type VaultDepositInfo struct { + Price Price `json:"price"` + Vault string `json:"vault"` +} + +// GetPrice returns the value of Price. +func (s *VaultDepositInfo) GetPrice() Price { + return s.Price +} + +// GetVault returns the value of Vault. +func (s *VaultDepositInfo) GetVault() string { + return s.Vault +} + +// SetPrice sets the value of Price. +func (s *VaultDepositInfo) SetPrice(val Price) { + s.Price = val +} + +// SetVault sets the value of Vault. +func (s *VaultDepositInfo) SetVault(val string) { + s.Vault = val +} + +// Ref: #/components/schemas/Wallet +type Wallet struct { + Address string `json:"address"` + IsWallet bool `json:"is_wallet"` + Balance int64 `json:"balance"` + Stats WalletStats `json:"stats"` + Plugins []WalletPlugin `json:"plugins"` + Status AccountStatus `json:"status"` + // Unix timestamp. + LastActivity int64 `json:"last_activity"` + Name OptString `json:"name"` + Icon OptString `json:"icon"` + // Deprecated: schema marks this property as deprecated. + GetMethods []string `json:"get_methods"` + IsSuspended OptBool `json:"is_suspended"` + SignatureDisabled OptBool `json:"signature_disabled"` + Interfaces []string `json:"interfaces"` + LastLt int64 `json:"last_lt"` +} + +// GetAddress returns the value of Address. +func (s *Wallet) GetAddress() string { + return s.Address +} + +// GetIsWallet returns the value of IsWallet. +func (s *Wallet) GetIsWallet() bool { + return s.IsWallet +} + +// GetBalance returns the value of Balance. +func (s *Wallet) GetBalance() int64 { + return s.Balance +} + +// GetStats returns the value of Stats. +func (s *Wallet) GetStats() WalletStats { + return s.Stats +} + +// GetPlugins returns the value of Plugins. +func (s *Wallet) GetPlugins() []WalletPlugin { + return s.Plugins +} + +// GetStatus returns the value of Status. +func (s *Wallet) GetStatus() AccountStatus { + return s.Status +} + +// GetLastActivity returns the value of LastActivity. +func (s *Wallet) GetLastActivity() int64 { + return s.LastActivity +} + +// GetName returns the value of Name. +func (s *Wallet) GetName() OptString { + return s.Name +} + +// GetIcon returns the value of Icon. +func (s *Wallet) GetIcon() OptString { + return s.Icon +} + +// GetGetMethods returns the value of GetMethods. +func (s *Wallet) GetGetMethods() []string { + return s.GetMethods +} + +// GetIsSuspended returns the value of IsSuspended. +func (s *Wallet) GetIsSuspended() OptBool { + return s.IsSuspended +} + +// GetSignatureDisabled returns the value of SignatureDisabled. +func (s *Wallet) GetSignatureDisabled() OptBool { + return s.SignatureDisabled +} + +// GetInterfaces returns the value of Interfaces. +func (s *Wallet) GetInterfaces() []string { + return s.Interfaces +} + +// GetLastLt returns the value of LastLt. +func (s *Wallet) GetLastLt() int64 { + return s.LastLt +} + +// SetAddress sets the value of Address. +func (s *Wallet) SetAddress(val string) { + s.Address = val +} + +// SetIsWallet sets the value of IsWallet. +func (s *Wallet) SetIsWallet(val bool) { + s.IsWallet = val +} + +// SetBalance sets the value of Balance. +func (s *Wallet) SetBalance(val int64) { + s.Balance = val +} + +// SetStats sets the value of Stats. +func (s *Wallet) SetStats(val WalletStats) { + s.Stats = val +} + +// SetPlugins sets the value of Plugins. +func (s *Wallet) SetPlugins(val []WalletPlugin) { + s.Plugins = val +} + +// SetStatus sets the value of Status. +func (s *Wallet) SetStatus(val AccountStatus) { + s.Status = val +} + +// SetLastActivity sets the value of LastActivity. +func (s *Wallet) SetLastActivity(val int64) { + s.LastActivity = val +} + +// SetName sets the value of Name. +func (s *Wallet) SetName(val OptString) { + s.Name = val +} + +// SetIcon sets the value of Icon. +func (s *Wallet) SetIcon(val OptString) { + s.Icon = val +} + +// SetGetMethods sets the value of GetMethods. +func (s *Wallet) SetGetMethods(val []string) { + s.GetMethods = val +} + +// SetIsSuspended sets the value of IsSuspended. +func (s *Wallet) SetIsSuspended(val OptBool) { + s.IsSuspended = val +} + +// SetSignatureDisabled sets the value of SignatureDisabled. +func (s *Wallet) SetSignatureDisabled(val OptBool) { + s.SignatureDisabled = val +} + +// SetInterfaces sets the value of Interfaces. +func (s *Wallet) SetInterfaces(val []string) { + s.Interfaces = val +} + +// SetLastLt sets the value of LastLt. +func (s *Wallet) SetLastLt(val int64) { + s.LastLt = val +} + // Ref: #/components/schemas/WalletDNS type WalletDNS struct { Address string `json:"address"` @@ -16581,6 +18971,106 @@ func (s *WalletDNS) SetNames(val []string) { s.Names = val } +// Ref: #/components/schemas/WalletPlugin +type WalletPlugin struct { + Address string `json:"address"` + Type string `json:"type"` + Status AccountStatus `json:"status"` +} + +// GetAddress returns the value of Address. +func (s *WalletPlugin) GetAddress() string { + return s.Address +} + +// GetType returns the value of Type. +func (s *WalletPlugin) GetType() string { + return s.Type +} + +// GetStatus returns the value of Status. +func (s *WalletPlugin) GetStatus() AccountStatus { + return s.Status +} + +// SetAddress sets the value of Address. +func (s *WalletPlugin) SetAddress(val string) { + s.Address = val +} + +// SetType sets the value of Type. +func (s *WalletPlugin) SetType(val string) { + s.Type = val +} + +// SetStatus sets the value of Status. +func (s *WalletPlugin) SetStatus(val AccountStatus) { + s.Status = val +} + +// Ref: #/components/schemas/WalletStats +type WalletStats struct { + NftsCount int32 `json:"nfts_count"` + JettonsCount int32 `json:"jettons_count"` + MultisigCount int32 `json:"multisig_count"` + StakingCount int32 `json:"staking_count"` +} + +// GetNftsCount returns the value of NftsCount. +func (s *WalletStats) GetNftsCount() int32 { + return s.NftsCount +} + +// GetJettonsCount returns the value of JettonsCount. +func (s *WalletStats) GetJettonsCount() int32 { + return s.JettonsCount +} + +// GetMultisigCount returns the value of MultisigCount. +func (s *WalletStats) GetMultisigCount() int32 { + return s.MultisigCount +} + +// GetStakingCount returns the value of StakingCount. +func (s *WalletStats) GetStakingCount() int32 { + return s.StakingCount +} + +// SetNftsCount sets the value of NftsCount. +func (s *WalletStats) SetNftsCount(val int32) { + s.NftsCount = val +} + +// SetJettonsCount sets the value of JettonsCount. +func (s *WalletStats) SetJettonsCount(val int32) { + s.JettonsCount = val +} + +// SetMultisigCount sets the value of MultisigCount. +func (s *WalletStats) SetMultisigCount(val int32) { + s.MultisigCount = val +} + +// SetStakingCount sets the value of StakingCount. +func (s *WalletStats) SetStakingCount(val int32) { + s.StakingCount = val +} + +// Ref: #/components/schemas/Wallets +type Wallets struct { + Accounts []Wallet `json:"accounts"` +} + +// GetAccounts returns the value of Accounts. +func (s *Wallets) GetAccounts() []Wallet { + return s.Accounts +} + +// SetAccounts sets the value of Accounts. +func (s *Wallets) SetAccounts(val []Wallet) { + s.Accounts = val +} + // Validator's participation in elections. // Ref: #/components/schemas/WithdrawStakeAction type WithdrawStakeAction struct { @@ -16679,6 +19169,43 @@ func (s *WithdrawStakeRequestAction) SetImplementation(val PoolImplementationTyp s.Implementation = val } +// Ref: #/components/schemas/WithdrawTokenStakeRequestAction +type WithdrawTokenStakeRequestAction struct { + Staker AccountAddress `json:"staker"` + Protocol Protocol `json:"protocol"` + StakeMeta OptPrice `json:"stake_meta"` +} + +// GetStaker returns the value of Staker. +func (s *WithdrawTokenStakeRequestAction) GetStaker() AccountAddress { + return s.Staker +} + +// GetProtocol returns the value of Protocol. +func (s *WithdrawTokenStakeRequestAction) GetProtocol() Protocol { + return s.Protocol +} + +// GetStakeMeta returns the value of StakeMeta. +func (s *WithdrawTokenStakeRequestAction) GetStakeMeta() OptPrice { + return s.StakeMeta +} + +// SetStaker sets the value of Staker. +func (s *WithdrawTokenStakeRequestAction) SetStaker(val AccountAddress) { + s.Staker = val +} + +// SetProtocol sets the value of Protocol. +func (s *WithdrawTokenStakeRequestAction) SetProtocol(val Protocol) { + s.Protocol = val +} + +// SetStakeMeta sets the value of StakeMeta. +func (s *WithdrawTokenStakeRequestAction) SetStakeMeta(val OptPrice) { + s.StakeMeta = val +} + // Ref: #/components/schemas/WorkchainDescr type WorkchainDescr struct { Workchain int `json:"workchain"` diff --git a/oas_security_gen.go b/oas_security_gen.go new file mode 100644 index 0000000..8758688 --- /dev/null +++ b/oas_security_gen.go @@ -0,0 +1,25 @@ +// Code generated by ogen, DO NOT EDIT. + +package tonapi + +import ( + "context" + "net/http" + + "github.com/go-faster/errors" +) + +// SecuritySource is provider of security values (tokens, passwords, etc.). +type SecuritySource interface { + // BearerAuth provides bearerAuth security value. + BearerAuth(ctx context.Context, operationName OperationName, client *Client) (BearerAuth, error) +} + +func (s *Client) securityBearerAuth(ctx context.Context, operationName OperationName, req *http.Request) error { + t, err := s.sec.BearerAuth(ctx, operationName, s) + if err != nil { + return errors.Wrap(err, "security source \"BearerAuth\"") + } + req.Header.Set("Authorization", "Bearer "+t.Token) + return nil +} diff --git a/oas_validators_gen.go b/oas_validators_gen.go index 9a060da..05bf95b 100644 --- a/oas_validators_gen.go +++ b/oas_validators_gen.go @@ -24,6 +24,10 @@ func (s AccStatusChange) Validate() error { } func (s *Account) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Status.Validate(); err != nil { @@ -54,6 +58,10 @@ func (s *Account) Validate() error { } func (s *AccountEvent) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Actions == nil { @@ -83,6 +91,26 @@ func (s *AccountEvent) Validate() error { Error: err, }) } + if err := func() error { + if err := (validate.Float{ + MinSet: true, + Min: 0, + MaxSet: true, + Max: 1, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: nil, + }).Validate(float64(s.Progress)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "progress", + Error: err, + }) + } if len(failures) > 0 { return &validate.Error{Fields: failures} } @@ -90,6 +118,10 @@ func (s *AccountEvent) Validate() error { } func (s *AccountEvents) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Events == nil { @@ -125,7 +157,51 @@ func (s *AccountEvents) Validate() error { return nil } +func (s *AccountPurchases) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Purchases == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.Purchases { + 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: "purchases", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *AccountStaking) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Pools == nil { @@ -160,6 +236,10 @@ func (s AccountStatus) Validate() error { } func (s *Accounts) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Accounts == nil { @@ -196,6 +276,10 @@ func (s *Accounts) Validate() error { } func (s *Action) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Type.Validate(); err != nil { @@ -327,6 +411,24 @@ func (s *Action) Validate() error { Error: err, }) } + if err := func() error { + if value, ok := s.Subscribe.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: "Subscribe", + Error: err, + }) + } if err := func() error { if value, ok := s.AuctionBid.Get(); ok { if err := func() error { @@ -454,7 +556,43 @@ func (s *Action) Validate() error { }) } if err := func() error { - if value, ok := s.InscriptionTransfer.Get(); ok { + if value, ok := s.Purchase.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: "Purchase", + Error: err, + }) + } + if err := func() error { + if value, ok := s.DepositTokenStake.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: "DepositTokenStake", + Error: err, + }) + } + if err := func() error { + if value, ok := s.WithdrawTokenStakeRequest.Get(); ok { if err := func() error { if err := value.Validate(); err != nil { return err @@ -467,12 +605,12 @@ func (s *Action) Validate() error { return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "InscriptionTransfer", + Name: "WithdrawTokenStakeRequest", Error: err, }) } if err := func() error { - if value, ok := s.InscriptionMint.Get(); ok { + if value, ok := s.LiquidityDeposit.Get(); ok { if err := func() error { if err := value.Validate(); err != nil { return err @@ -485,7 +623,7 @@ func (s *Action) Validate() error { return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "InscriptionMint", + Name: "LiquidityDeposit", Error: err, }) } @@ -518,6 +656,10 @@ func (s *Action) Validate() error { } func (s *ActionSimplePreview) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Accounts == nil { @@ -551,6 +693,10 @@ func (s ActionType) Validate() error { switch s { case "TonTransfer": return nil + case "ExtraCurrencyTransfer": + return nil + case "ContractDeploy": + return nil case "JettonTransfer": return nil case "JettonBurn": @@ -559,8 +705,6 @@ func (s ActionType) Validate() error { return nil case "NftItemTransfer": return nil - case "ContractDeploy": - return nil case "Subscribe": return nil case "UnSubscribe": @@ -575,19 +719,31 @@ func (s ActionType) Validate() error { return nil case "WithdrawStakeRequest": return nil + case "ElectionsDepositStake": + return nil + case "ElectionsRecoverStake": + return nil case "JettonSwap": return nil case "SmartContractExec": return nil - case "ElectionsRecoverStake": + case "DomainRenew": return nil - case "ElectionsDepositStake": + case "Purchase": return nil - case "DomainRenew": + case "AddExtension": + return nil + case "RemoveExtension": + return nil + case "SetSignatureAllowedAction": return nil - case "InscriptionTransfer": + case "GasRelay": return nil - case "InscriptionMint": + case "DepositTokenStake": + return nil + case "WithdrawTokenStakeRequest": + return nil + case "LiquidityDeposit": return nil case "Unknown": return nil @@ -597,6 +753,10 @@ func (s ActionType) Validate() error { } func (s *ApyHistory) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := (validate.Float{}).Validate(float64(s.Apy)); err != nil { @@ -616,6 +776,10 @@ func (s *ApyHistory) Validate() error { } func (s *AuctionBidAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.AuctionType.Validate(); err != nil { @@ -628,6 +792,17 @@ func (s *AuctionBidAction) Validate() error { Error: err, }) } + if err := func() error { + if err := s.Amount.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "amount", + Error: err, + }) + } if err := func() error { if value, ok := s.Nft.Get(); ok { if err := func() error { @@ -668,6 +843,10 @@ func (s AuctionBidActionAuctionType) Validate() error { } func (s *Auctions) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Data == nil { @@ -687,6 +866,10 @@ func (s *Auctions) Validate() error { } func (s *BlockCurrencyCollection) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Other == nil { @@ -706,6 +889,10 @@ func (s *BlockCurrencyCollection) Validate() error { } func (s *BlockValueFlow) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.FromPrevBlk.Validate(); err != nil { @@ -831,6 +1018,10 @@ func (s *BlockValueFlow) Validate() error { } func (s *BlockchainAccountInspect) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Methods == nil { @@ -844,7 +1035,18 @@ func (s *BlockchainAccountInspect) Validate() error { }) } if err := func() error { - if value, ok := s.Compiler.Get(); ok { + if err := s.Compiler.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "compiler", + Error: err, + }) + } + if err := func() error { + if value, ok := s.Source.Get(); ok { if err := func() error { if err := value.Validate(); err != nil { return err @@ -857,7 +1059,7 @@ func (s *BlockchainAccountInspect) Validate() error { return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "compiler", + Name: "source", Error: err, }) } @@ -871,12 +1073,20 @@ func (s BlockchainAccountInspectCompiler) Validate() error { switch s { case "func": return nil + case "fift": + return nil + case "tact": + return nil default: return errors.Errorf("invalid value: %v", s) } } func (s *BlockchainBlock) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.ValueFlow.Validate(); err != nil { @@ -907,6 +1117,10 @@ func (s *BlockchainBlock) Validate() error { } func (s *BlockchainBlockShards) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Shards == nil { @@ -943,6 +1157,10 @@ func (s *BlockchainBlockShards) Validate() error { } func (s *BlockchainBlockShardsShardsItem) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.LastKnownBlock.Validate(); err != nil { @@ -962,6 +1180,10 @@ func (s *BlockchainBlockShardsShardsItem) Validate() error { } func (s *BlockchainBlocks) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Blocks == nil { @@ -998,6 +1220,10 @@ func (s *BlockchainBlocks) Validate() error { } func (s *BlockchainConfig) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if value, ok := s.R7.Get(); ok { @@ -1226,6 +1452,24 @@ func (s *BlockchainConfig) Validate() error { Error: err, }) } + if err := func() error { + if value, ok := s.R45.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: "45", + Error: err, + }) + } if err := func() error { if value, ok := s.R71.Get(); ok { if err := func() error { @@ -1341,6 +1585,10 @@ func (s *BlockchainConfig) Validate() error { } func (s *BlockchainConfig10) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.CriticalParams == nil { @@ -1360,6 +1608,10 @@ func (s *BlockchainConfig10) Validate() error { } func (s *BlockchainConfig12) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Workchains == nil { @@ -1379,6 +1631,10 @@ func (s *BlockchainConfig12) Validate() error { } func (s *BlockchainConfig18) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.StoragePrices == nil { @@ -1398,6 +1654,10 @@ func (s *BlockchainConfig18) Validate() error { } func (s *BlockchainConfig31) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.FundamentalSmcAddr == nil { @@ -1417,6 +1677,10 @@ func (s *BlockchainConfig31) Validate() error { } func (s *BlockchainConfig44) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Accounts == nil { @@ -1435,7 +1699,34 @@ func (s *BlockchainConfig44) Validate() error { return nil } +func (s *BlockchainConfig45) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Contracts == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "contracts", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *BlockchainConfig7) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Currencies == nil { @@ -1455,6 +1746,10 @@ func (s *BlockchainConfig7) Validate() error { } func (s *BlockchainConfig71) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.OracleBridgeParams.Validate(); err != nil { @@ -1474,6 +1769,10 @@ func (s *BlockchainConfig71) Validate() error { } func (s *BlockchainConfig72) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.OracleBridgeParams.Validate(); err != nil { @@ -1493,6 +1792,10 @@ func (s *BlockchainConfig72) Validate() error { } func (s *BlockchainConfig73) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.OracleBridgeParams.Validate(); err != nil { @@ -1512,6 +1815,10 @@ func (s *BlockchainConfig73) Validate() error { } func (s *BlockchainConfig79) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.JettonBridgeParams.Validate(); err != nil { @@ -1531,6 +1838,10 @@ func (s *BlockchainConfig79) Validate() error { } func (s *BlockchainConfig81) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.JettonBridgeParams.Validate(); err != nil { @@ -1550,6 +1861,10 @@ func (s *BlockchainConfig81) Validate() error { } func (s *BlockchainConfig82) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.JettonBridgeParams.Validate(); err != nil { @@ -1569,6 +1884,10 @@ func (s *BlockchainConfig82) Validate() error { } func (s *BlockchainConfig9) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.MandatoryParams == nil { @@ -1588,6 +1907,10 @@ func (s *BlockchainConfig9) Validate() error { } func (s *BlockchainRawAccount) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Status.Validate(); err != nil { @@ -1619,7 +1942,61 @@ func (s BouncePhaseType) Validate() error { } } +func (s ChartPoints) Validate() error { + alias := ([][]float64)(s) + if alias == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range alias { + if err := func() error { + if elem == nil { + return errors.New("nil is invalid value") + } + if err := (validate.Array{ + MinLength: 2, + MinLengthSet: true, + MaxLength: 2, + MaxLengthSet: true, + }).ValidateLength(len(elem)); err != nil { + return errors.Wrap(err, "array") + } + var failures []validate.FieldError + for i, elem := range elem { + if err := func() error { + if err := (validate.Float{}).Validate(float64(elem)); err != nil { + return errors.Wrap(err, "float") + } + 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: fmt.Sprintf("[%d]", i), + Error: err, + }) + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *ComputePhase) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if value, ok := s.SkipReason.Get(); ok { @@ -1653,12 +2030,18 @@ func (s ComputeSkipReason) Validate() error { return nil case "cskip_no_gas": return nil + case "cskip_suspended": + return nil default: return errors.Errorf("invalid value: %v", s) } } func (s *ContractDeployAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Interfaces == nil { @@ -1677,7 +2060,26 @@ func (s *ContractDeployAction) Validate() error { return nil } +func (s CurrencyType) Validate() error { + switch s { + case "native": + return nil + case "extra_currency": + return nil + case "jetton": + return nil + case "fiat": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + func (s *DecodedMessage) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if value, ok := s.ExtInMsgDecoded.Get(); ok { @@ -1704,6 +2106,10 @@ func (s *DecodedMessage) Validate() error { } func (s *DecodedMessageExtInMsgDecoded) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if value, ok := s.WalletV3.Get(); ok { @@ -1741,6 +2147,24 @@ func (s *DecodedMessageExtInMsgDecoded) Validate() error { Error: err, }) } + if err := func() error { + if value, ok := s.WalletV5.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_v5", + Error: err, + }) + } if err := func() error { if value, ok := s.WalletHighloadV2.Get(); ok { if err := func() error { @@ -1766,6 +2190,10 @@ func (s *DecodedMessageExtInMsgDecoded) Validate() error { } func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.RawMessages == nil { @@ -1785,6 +2213,10 @@ func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) Validate() error { } func (s *DecodedMessageExtInMsgDecodedWalletV3) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.RawMessages == nil { @@ -1804,6 +2236,33 @@ func (s *DecodedMessageExtInMsgDecodedWalletV3) Validate() error { } func (s *DecodedMessageExtInMsgDecodedWalletV4) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + 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 *DecodedMessageExtInMsgDecodedWalletV5) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.RawMessages == nil { @@ -1823,6 +2282,10 @@ func (s *DecodedMessageExtInMsgDecodedWalletV4) Validate() error { } func (s *DepositStakeAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Implementation.Validate(); err != nil { @@ -1841,7 +2304,41 @@ func (s *DepositStakeAction) Validate() error { return nil } +func (s *DepositTokenStakeAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.StakeMeta.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: "stake_meta", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *DnsExpiring) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Items == nil { @@ -1878,6 +2375,10 @@ func (s *DnsExpiring) Validate() error { } func (s *DnsExpiringItemsItem) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if value, ok := s.DNSItem.Get(); ok { @@ -1904,6 +2405,10 @@ func (s *DnsExpiringItemsItem) Validate() error { } func (s *DnsRecord) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if value, ok := s.Wallet.Get(); ok { @@ -1941,6 +2446,10 @@ func (s *DnsRecord) Validate() error { } func (s *DomainBids) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Data == nil { @@ -1960,6 +2469,10 @@ func (s *DomainBids) Validate() error { } func (s *DomainInfo) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if value, ok := s.Item.Get(); ok { @@ -1986,6 +2499,10 @@ func (s *DomainInfo) Validate() error { } func (s *DomainNames) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Domains == nil { @@ -2005,6 +2522,10 @@ func (s *DomainNames) Validate() error { } func (s *Event) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Actions == nil { @@ -2062,22 +2583,23 @@ func (s *Event) Validate() error { Error: err, }) } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil -} - -func (s *FoundAccounts) Validate() error { - var failures []validate.FieldError if err := func() error { - if s.Addresses == nil { - return errors.New("nil is invalid value") + if err := (validate.Float{ + MinSet: true, + Min: 0, + MaxSet: true, + Max: 1, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: nil, + }).Validate(float64(s.Progress)); err != nil { + return errors.Wrap(err, "float") } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "addresses", + Name: "progress", Error: err, }) } @@ -2087,16 +2609,20 @@ func (s *FoundAccounts) Validate() error { return nil } -func (s *GaslessConfig) Validate() error { +func (s *ExecGetMethodArg) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if s.GasJettons == nil { - return errors.New("nil is invalid value") + if err := s.Type.Validate(); err != nil { + return err } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "gas_jettons", + Name: "type", Error: err, }) } @@ -2106,35 +2632,58 @@ func (s *GaslessConfig) Validate() error { return nil } -func (s *GaslessEstimateReq) Validate() error { - var failures []validate.FieldError - if err := func() error { - if s.Messages == nil { - return errors.New("nil is invalid value") - } +func (s ExecGetMethodArgType) Validate() error { + switch s { + case "nan": return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "messages", - Error: err, - }) - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} + case "null": + return nil + case "tinyint": + return nil + case "int257": + return nil + case "slice": + return nil + case "cell_boc_base64": + return nil + case "slice_boc_hex": + return nil + default: + return errors.Errorf("invalid value: %v", s) } - return nil } -func (s *GetAccountsReq) Validate() error { +func (s *ExecGetMethodWithBodyForBlockchainAccountReq) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if s.AccountIds == nil { + if s.Args == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range s.Args { + 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: "account_ids", + Name: "args", Error: err, }) } @@ -2144,45 +2693,18 @@ func (s *GetAccountsReq) Validate() error { return nil } -func (s GetBlockchainAccountTransactionsSortOrder) Validate() error { - switch s { - case "desc": - return nil - case "asc": - return nil - default: - return errors.Errorf("invalid value: %v", s) - } -} - -func (s GetInscriptionOpTemplateOperation) Validate() error { - switch s { - case "transfer": - return nil - default: - return errors.Errorf("invalid value: %v", s) - } -} - -func (s GetInscriptionOpTemplateType) Validate() error { - switch s { - case "ton20": - return nil - case "gram20": - return nil - default: - return errors.Errorf("invalid value: %v", s) +func (s *FoundAccounts) Validate() error { + if s == nil { + return validate.ErrNilPointer } -} -func (s *GetMarketsRatesOK) Validate() error { var failures []validate.FieldError if err := func() error { - if s.Markets == nil { + if s.Addresses == nil { return errors.New("nil is invalid value") } var failures []validate.FieldError - for i, elem := range s.Markets { + for i, elem := range s.Addresses { if err := func() error { if err := elem.Validate(); err != nil { return err @@ -2201,7 +2723,7 @@ func (s *GetMarketsRatesOK) Validate() error { return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "markets", + Name: "addresses", Error: err, }) } @@ -2211,16 +2733,20 @@ func (s *GetMarketsRatesOK) Validate() error { return nil } -func (s *GetNftItemsByAddressesReq) Validate() error { +func (s *FoundAccountsAddressesItem) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if s.AccountIds == nil { - return errors.New("nil is invalid value") + if err := s.Trust.Validate(); err != nil { + return err } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "account_ids", + Name: "trust", Error: err, }) } @@ -2230,16 +2756,20 @@ func (s *GetNftItemsByAddressesReq) Validate() error { return nil } -func (s *GetOutMsgQueueSizesOK) Validate() error { +func (s *GaslessConfig) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if s.Shards == nil { + if s.GasJettons == nil { return errors.New("nil is invalid value") } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "shards", + Name: "gas_jettons", Error: err, }) } @@ -2249,16 +2779,20 @@ func (s *GetOutMsgQueueSizesOK) Validate() error { return nil } -func (s *GetRatesOK) Validate() error { +func (s *GaslessEstimateReq) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if err := s.Rates.Validate(); err != nil { - return err + if s.Messages == nil { + return errors.New("nil is invalid value") } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "rates", + Name: "messages", Error: err, }) } @@ -2268,33 +2802,249 @@ func (s *GetRatesOK) Validate() error { return nil } -func (s GetRatesOKRates) Validate() error { +func (s *GetAccountsReq) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError - for key, elem := range s { - if err := func() error { - if err := elem.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: key, - Error: err, - }) + if err := func() error { + if s.AccountIds == nil { + return errors.New("nil is invalid value") } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "account_ids", + Error: err, + }) } - if len(failures) > 0 { return &validate.Error{Fields: failures} } return nil } -func (s *GetRawBlockProofOK) Validate() error { - var failures []validate.FieldError - if err := func() error { - if s.Steps == nil { - return errors.New("nil is invalid value") +func (s GetBlockchainAccountTransactionsSortOrder) Validate() error { + switch s { + case "desc": + return nil + case "asc": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + +func (s *GetChartRatesOK) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.Points.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "points", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *GetJettonInfosByAddressesReq) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.AccountIds == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "account_ids", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *GetMarketsRatesOK) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Markets == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.Markets { + 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: "markets", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *GetNftCollectionItemsByAddressesReq) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.AccountIds == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "account_ids", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *GetNftItemsByAddressesReq) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.AccountIds == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "account_ids", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *GetOutMsgQueueSizesOK) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Shards == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "shards", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *GetRatesOK) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.Rates.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "rates", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s GetRatesOKRates) Validate() error { + var failures []validate.FieldError + for key, elem := range s { + if err := func() error { + if err := elem.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: key, + Error: err, + }) + } + } + + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *GetRawBlockProofOK) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Steps == nil { + return errors.New("nil is invalid value") } var failures []validate.FieldError for i, elem := range s.Steps { @@ -2327,6 +3077,10 @@ func (s *GetRawBlockProofOK) Validate() error { } func (s *GetRawBlockProofOKStepsItem) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.LiteServerBlockLinkForward.Validate(); err != nil { @@ -2346,6 +3100,10 @@ func (s *GetRawBlockProofOKStepsItem) Validate() error { } func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Signatures.Validate(); err != nil { @@ -2365,6 +3123,10 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) Validate() error } func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Signatures == nil { @@ -2384,6 +3146,10 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) Valida } func (s *GetRawListBlockTransactionsOK) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Ids == nil { @@ -2403,6 +3169,10 @@ func (s *GetRawListBlockTransactionsOK) Validate() error { } func (s *GetRawShardBlockProofOK) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Links == nil { @@ -2422,6 +3192,10 @@ func (s *GetRawShardBlockProofOK) Validate() error { } func (s *GetRawTransactionsOK) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Ids == nil { @@ -2441,6 +3215,10 @@ func (s *GetRawTransactionsOK) Validate() error { } func (s *GetStakingPoolHistoryOK) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Apy == nil { @@ -2477,6 +3255,10 @@ func (s *GetStakingPoolHistoryOK) Validate() error { } func (s *GetStakingPoolInfoOK) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Implementation.Validate(); err != nil { @@ -2507,6 +3289,10 @@ func (s *GetStakingPoolInfoOK) Validate() error { } func (s *GetStakingPoolsOK) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Pools == nil { @@ -2576,6 +3362,10 @@ func (s GetStakingPoolsOKImplementations) Validate() error { } func (s *GetStorageProvidersOK) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Providers == nil { @@ -2594,82 +3384,38 @@ func (s *GetStorageProvidersOK) Validate() error { return nil } -func (s *InscriptionBalance) Validate() error { - var failures []validate.FieldError - if err := func() error { - if err := s.Type.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "type", - Error: err, - }) - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} +func (s *JettonBalance) Validate() error { + if s == nil { + return validate.ErrNilPointer } - return nil -} -func (s InscriptionBalanceType) Validate() error { - switch s { - case "ton20": - return nil - case "gram20": - return nil - default: - return errors.Errorf("invalid value: %v", s) - } -} - -func (s *InscriptionBalances) Validate() error { var failures []validate.FieldError if err := func() error { - if s.Inscriptions == nil { - return errors.New("nil is invalid value") - } - var failures []validate.FieldError - for i, elem := range s.Inscriptions { + if value, ok := s.Price.Get(); ok { if err := func() error { - if err := elem.Validate(); err != nil { + if err := value.Validate(); err != nil { return err } return nil }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: fmt.Sprintf("[%d]", i), - Error: err, - }) + return err } } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "inscriptions", + Name: "price", Error: err, }) } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - return nil -} - -func (s *InscriptionMintAction) Validate() error { - var failures []validate.FieldError if err := func() error { - if err := s.Type.Validate(); err != nil { + if err := s.Jetton.Validate(); err != nil { return err } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "type", + Name: "jetton", Error: err, }) } @@ -2679,27 +3425,20 @@ func (s *InscriptionMintAction) Validate() error { return nil } -func (s InscriptionMintActionType) Validate() error { - switch s { - case "ton20": - return nil - case "gram20": - return nil - default: - return errors.Errorf("invalid value: %v", s) +func (s *JettonBridgeParams) Validate() error { + if s == nil { + return validate.ErrNilPointer } -} -func (s *InscriptionTransferAction) Validate() error { var failures []validate.FieldError if err := func() error { - if err := s.Type.Validate(); err != nil { - return err + if s.Oracles == nil { + return errors.New("nil is invalid value") } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "type", + Name: "oracles", Error: err, }) } @@ -2709,37 +3448,12 @@ func (s *InscriptionTransferAction) Validate() error { return nil } -func (s InscriptionTransferActionType) Validate() error { - switch s { - case "ton20": - return nil - case "gram20": - return nil - default: - return errors.Errorf("invalid value: %v", s) +func (s *JettonBurnAction) Validate() error { + if s == nil { + return validate.ErrNilPointer } -} -func (s *JettonBalance) Validate() error { var failures []validate.FieldError - if err := func() error { - if value, ok := s.Price.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: "price", - Error: err, - }) - } if err := func() error { if err := s.Jetton.Validate(); err != nil { return err @@ -2757,16 +3471,20 @@ func (s *JettonBalance) Validate() error { return nil } -func (s *JettonBridgeParams) Validate() error { +func (s *JettonHolders) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if s.Oracles == nil { + if s.Addresses == nil { return errors.New("nil is invalid value") } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "oracles", + Name: "addresses", Error: err, }) } @@ -2776,16 +3494,20 @@ func (s *JettonBridgeParams) Validate() error { return nil } -func (s *JettonBurnAction) Validate() error { +func (s *JettonInfo) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if err := s.Jetton.Validate(); err != nil { + if err := s.Verification.Validate(); err != nil { return err } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "jetton", + Name: "verification", Error: err, }) } @@ -2795,16 +3517,20 @@ func (s *JettonBurnAction) Validate() error { return nil } -func (s *JettonHolders) Validate() error { +func (s *JettonMintAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if s.Addresses == nil { - return errors.New("nil is invalid value") + if err := s.Jetton.Validate(); err != nil { + return err } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "addresses", + Name: "jetton", Error: err, }) } @@ -2814,16 +3540,31 @@ func (s *JettonHolders) Validate() error { return nil } -func (s *JettonInfo) Validate() error { +func (s *JettonOperation) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if err := s.Verification.Validate(); err != nil { + if err := s.Operation.Validate(); err != nil { return err } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "verification", + Name: "operation", + Error: err, + }) + } + if err := func() error { + if err := s.Jetton.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "jetton", Error: err, }) } @@ -2833,16 +3574,50 @@ func (s *JettonInfo) Validate() error { return nil } -func (s *JettonMintAction) Validate() error { +func (s JettonOperationOperation) Validate() error { + switch s { + case "transfer": + return nil + case "mint": + return nil + case "burn": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + +func (s *JettonOperations) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if err := s.Jetton.Validate(); err != nil { - return err + if s.Operations == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.Operations { + 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: "jetton", + Name: "operations", Error: err, }) } @@ -2853,6 +3628,10 @@ func (s *JettonMintAction) Validate() error { } func (s *JettonPreview) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Verification.Validate(); err != nil { @@ -2872,6 +3651,10 @@ func (s *JettonPreview) Validate() error { } func (s *JettonQuantity) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Jetton.Validate(); err != nil { @@ -2891,18 +3674,11 @@ func (s *JettonQuantity) Validate() error { } func (s *JettonSwapAction) Validate() error { - var failures []validate.FieldError - if err := func() error { - if err := s.Dex.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "dex", - Error: err, - }) + if s == nil { + return validate.ErrNilPointer } + + var failures []validate.FieldError if err := func() error { if value, ok := s.JettonMasterIn.Get(); ok { if err := func() error { @@ -2945,20 +3721,11 @@ func (s *JettonSwapAction) Validate() error { return nil } -func (s JettonSwapActionDex) Validate() error { - switch s { - case "stonfi": - return nil - case "dedust": - return nil - case "megatonfi": - return nil - default: - return errors.Errorf("invalid value: %v", s) - } -} - func (s *JettonTransferAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if value, ok := s.Refund.Get(); ok { @@ -2999,6 +3766,8 @@ func (s JettonVerificationType) Validate() error { switch s { case "whitelist": return nil + case "graylist": + return nil case "blacklist": return nil case "none": @@ -3009,6 +3778,10 @@ func (s JettonVerificationType) Validate() error { } func (s *Jettons) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Jettons == nil { @@ -3045,6 +3818,10 @@ func (s *Jettons) Validate() error { } func (s *JettonsBalances) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Balances == nil { @@ -3080,7 +3857,51 @@ func (s *JettonsBalances) Validate() error { return nil } +func (s *LiquidityDepositAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Tokens == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.Tokens { + 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: "tokens", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *MarketTonRates) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := (validate.Float{}).Validate(float64(s.UsdPrice)); err != nil { @@ -3100,6 +3921,10 @@ func (s *MarketTonRates) Validate() error { } func (s *Message) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.MsgType.Validate(); err != nil { @@ -3137,6 +3962,10 @@ func (s *Message) Validate() error { } func (s *MessageConsequences) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Trace.Validate(); err != nil { @@ -3191,6 +4020,10 @@ func (s MessageMsgType) Validate() error { } func (s *MethodExecutionResult) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Stack == nil { @@ -3227,6 +4060,10 @@ func (s *MethodExecutionResult) Validate() error { } func (s *Multisig) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Signers == nil { @@ -3285,6 +4122,10 @@ func (s *Multisig) Validate() error { } func (s *MultisigOrder) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Signers == nil { @@ -3308,6 +4149,69 @@ func (s *MultisigOrder) Validate() error { Error: err, }) } + if err := func() error { + if s.SignedBy == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "signed_by", + Error: err, + }) + } + if err := func() error { + if value, ok := s.ChangingParameters.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: "changing_parameters", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *MultisigOrderChangingParameters) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Signers == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "signers", + Error: err, + }) + } + if err := func() error { + if s.Proposers == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "proposers", + Error: err, + }) + } if len(failures) > 0 { return &validate.Error{Fields: failures} } @@ -3315,6 +4219,10 @@ func (s *MultisigOrder) Validate() error { } func (s *Multisigs) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Multisigs == nil { @@ -3381,14 +4289,16 @@ func (s NftApprovedByItem) Validate() error { return nil case "tonkeeper": return nil - case "ton.diamonds": - return nil default: return errors.Errorf("invalid value: %v", s) } } func (s *NftCollection) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.ApprovedBy.Validate(); err != nil { @@ -3408,6 +4318,10 @@ func (s *NftCollection) Validate() error { } func (s *NftCollections) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.NftCollections == nil { @@ -3433,7 +4347,157 @@ func (s *NftCollections) Validate() error { return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "nft_collections", + Name: "nft_collections", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *NftItem) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.Sale.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: "sale", + Error: err, + }) + } + if err := func() error { + if s.ApprovedBy == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.ApprovedBy { + 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: "approved_by", + Error: err, + }) + } + if err := func() error { + if err := s.Trust.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "trust", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s NftItemApprovedByItem) Validate() error { + switch s { + case "getgems": + return nil + case "tonkeeper": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + +func (s *NftItemTransferAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.Refund.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: "refund", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *NftItems) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.NftItems == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.NftItems { + 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: "nft_items", Error: err, }) } @@ -3443,27 +4507,20 @@ func (s *NftCollections) Validate() error { return nil } -func (s *NftItem) Validate() error { - var failures []validate.FieldError - if err := func() error { - if err := s.ApprovedBy.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - failures = append(failures, validate.FieldError{ - Name: "approved_by", - Error: err, - }) +func (s *NftOperation) Validate() error { + if s == nil { + return validate.ErrNilPointer } + + var failures []validate.FieldError if err := func() error { - if err := s.Trust.Validate(); err != nil { + if err := s.Item.Validate(); err != nil { return err } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "trust", + Name: "item", Error: err, }) } @@ -3473,40 +4530,18 @@ func (s *NftItem) Validate() error { return nil } -func (s *NftItemTransferAction) Validate() error { - var failures []validate.FieldError - if err := func() error { - if value, ok := s.Refund.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: "refund", - Error: err, - }) - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} +func (s *NftOperations) Validate() error { + if s == nil { + return validate.ErrNilPointer } - return nil -} -func (s *NftItems) Validate() error { var failures []validate.FieldError if err := func() error { - if s.NftItems == nil { + if s.Operations == nil { return errors.New("nil is invalid value") } var failures []validate.FieldError - for i, elem := range s.NftItems { + for i, elem := range s.Operations { if err := func() error { if err := elem.Validate(); err != nil { return err @@ -3525,7 +4560,7 @@ func (s *NftItems) Validate() error { return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "nft_items", + Name: "operations", Error: err, }) } @@ -3536,6 +4571,10 @@ func (s *NftItems) Validate() error { } func (s *NftPurchaseAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.AuctionType.Validate(); err != nil { @@ -3548,6 +4587,17 @@ func (s *NftPurchaseAction) Validate() error { Error: err, }) } + if err := func() error { + if err := s.Amount.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "amount", + Error: err, + }) + } if err := func() error { if err := s.Nft.Validate(); err != nil { return err @@ -3581,6 +4631,10 @@ func (s NftPurchaseActionAuctionType) Validate() error { } func (s *OracleBridgeParams) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Oracles == nil { @@ -3600,6 +4654,10 @@ func (s *OracleBridgeParams) Validate() error { } func (s *PoolImplementation) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Socials == nil { @@ -3632,6 +4690,10 @@ func (s PoolImplementationType) Validate() error { } func (s *PoolInfo) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Implementation.Validate(); err != nil { @@ -3661,7 +4723,91 @@ func (s *PoolInfo) Validate() error { return nil } +func (s *Price) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.CurrencyType.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "currency_type", + Error: err, + }) + } + if err := func() error { + if err := s.Verification.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "verification", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *Purchase) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.Amount.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "amount", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *PurchaseAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.Amount.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "amount", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *ReducedBlock) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.ShardsBlocks == nil { @@ -3692,6 +4838,10 @@ func (s *ReducedBlock) Validate() error { } func (s *ReducedBlocks) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Blocks == nil { @@ -3728,6 +4878,10 @@ func (s *ReducedBlocks) Validate() error { } func (s *Refund) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Type.Validate(); err != nil { @@ -3760,6 +4914,10 @@ func (s RefundType) Validate() error { } func (s *Risk) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Jettons == nil { @@ -3817,6 +4975,47 @@ func (s *Risk) Validate() error { Error: err, }) } + if err := func() error { + if value, ok := s.TotalEquivalent.Get(); ok { + if err := func() error { + if err := (validate.Float{}).Validate(float64(value)); err != nil { + return errors.Wrap(err, "float") + } + return nil + }(); err != nil { + return err + } + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "total_equivalent", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *Sale) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.Price.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "price", + Error: err, + }) + } if len(failures) > 0 { return &validate.Error{Fields: failures} } @@ -3824,12 +5023,16 @@ func (s *Risk) Validate() error { } func (s *SendBlockchainMessageReq) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := (validate.Array{ MinLength: 0, MinLengthSet: false, - MaxLength: 10, + MaxLength: 5, MaxLengthSet: true, }).ValidateLength(len(s.Batch)); err != nil { return errors.Wrap(err, "array") @@ -3848,6 +5051,10 @@ func (s *SendBlockchainMessageReq) Validate() error { } func (s *SignRawParams) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Messages == nil { @@ -3860,29 +5067,120 @@ func (s *SignRawParams) Validate() error { Error: err, }) } + if err := func() error { + if value, ok := s.Emulation.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: "emulation", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *SmartContractAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.Refund.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: "refund", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *Source) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Files == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "files", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *StateInit) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Interfaces == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "interfaces", + Error: err, + }) + } if len(failures) > 0 { return &validate.Error{Fields: failures} } return nil } -func (s *SmartContractAction) Validate() error { +func (s *StoragePhase) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if value, ok := s.Refund.Get(); ok { - if err := func() error { - if err := value.Validate(); err != nil { - return err - } - return nil - }(); err != nil { - return err - } + if err := s.StatusChange.Validate(); err != nil { + return err } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "refund", + Name: "status_change", Error: err, }) } @@ -3892,16 +5190,31 @@ func (s *SmartContractAction) Validate() error { return nil } -func (s *StateInit) Validate() error { +func (s *Subscription) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if s.Interfaces == nil { - return errors.New("nil is invalid value") + if err := s.Status.Validate(); err != nil { + return err } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "interfaces", + Name: "status", + Error: err, + }) + } + if err := func() error { + if err := s.PaymentPerPeriod.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "payment_per_period", Error: err, }) } @@ -3911,16 +5224,20 @@ func (s *StateInit) Validate() error { return nil } -func (s *StoragePhase) Validate() error { +func (s *SubscriptionAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { - if err := s.StatusChange.Validate(); err != nil { + if err := s.Price.Validate(); err != nil { return err } return nil }(); err != nil { failures = append(failures, validate.FieldError{ - Name: "status_change", + Name: "price", Error: err, }) } @@ -3930,12 +5247,48 @@ func (s *StoragePhase) Validate() error { return nil } +func (s SubscriptionStatus) Validate() error { + switch s { + case "not_ready": + return nil + case "active": + return nil + case "suspended": + return nil + case "cancelled": + return nil + default: + return errors.Errorf("invalid value: %v", s) + } +} + func (s *Subscriptions) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Subscriptions == nil { return errors.New("nil is invalid value") } + var failures []validate.FieldError + for i, elem := range s.Subscriptions { + 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{ @@ -3950,6 +5303,10 @@ func (s *Subscriptions) Validate() error { } func (s *TokenRates) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if value, ok := s.Prices.Get(); ok { @@ -3998,6 +5355,10 @@ func (s TokenRatesPrices) Validate() error { } func (s *TonTransferAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if value, ok := s.Refund.Get(); ok { @@ -4024,6 +5385,10 @@ func (s *TonTransferAction) Validate() error { } func (s *Trace) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Transaction.Validate(); err != nil { @@ -4079,6 +5444,10 @@ func (s *Trace) Validate() error { } func (s *TraceIDs) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Traces == nil { @@ -4098,6 +5467,10 @@ func (s *TraceIDs) Validate() error { } func (s *Transaction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.OrigStatus.Validate(); err != nil { @@ -4260,6 +5633,10 @@ func (s TransactionType) Validate() error { } func (s *Transactions) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Transactions == nil { @@ -4311,6 +5688,10 @@ func (s TrustType) Validate() error { } func (s *TvmStackRecord) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Type.Validate(); err != nil { @@ -4372,6 +5753,10 @@ func (s TvmStackRecordType) Validate() error { } func (s *Validators) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Validators == nil { @@ -4391,6 +5776,10 @@ func (s *Validators) Validate() error { } func (s *ValidatorsSet) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.List == nil { @@ -4410,6 +5799,10 @@ func (s *ValidatorsSet) Validate() error { } func (s *ValueFlow) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { var failures []validate.FieldError @@ -4443,6 +5836,10 @@ func (s *ValueFlow) Validate() error { } func (s *ValueFlowJettonsItem) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Jetton.Validate(); err != nil { @@ -4461,7 +5858,96 @@ func (s *ValueFlowJettonsItem) Validate() error { return nil } +func (s *VaultDepositInfo) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.Price.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "price", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *Wallet) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Plugins == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.Plugins { + 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: "plugins", + Error: err, + }) + } + if err := func() error { + if err := s.Status.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "status", + Error: err, + }) + } + if err := func() error { + if s.GetMethods == nil { + return errors.New("nil is invalid value") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "get_methods", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *WalletDNS) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if s.Names == nil { @@ -4480,7 +5966,74 @@ func (s *WalletDNS) Validate() error { return nil } +func (s *WalletPlugin) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := s.Status.Validate(); err != nil { + return err + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "status", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *Wallets) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Accounts == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.Accounts { + 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: "accounts", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *WithdrawStakeAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Implementation.Validate(); err != nil { @@ -4500,6 +6053,10 @@ func (s *WithdrawStakeAction) Validate() error { } func (s *WithdrawStakeRequestAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + var failures []validate.FieldError if err := func() error { if err := s.Implementation.Validate(); err != nil { @@ -4517,3 +6074,33 @@ func (s *WithdrawStakeRequestAction) Validate() error { } return nil } + +func (s *WithdrawTokenStakeRequestAction) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if value, ok := s.StakeMeta.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: "stake_meta", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} diff --git a/tonapi.go b/tonapi.go index 3590a5a..9dbe974 100644 --- a/tonapi.go +++ b/tonapi.go @@ -67,7 +67,7 @@ func (c *Client) GetAccountState(ctx context.Context, accountID tongo.AccountID) // Request sends an HTTP request with the given method, URL, parameters, and data, // and returns the response as a json.RawMessage. -func (c *Client) Request(ctx context.Context, method, endpoint string, query map[string]string, data []byte) (json.RawMessage, error) { +func (c *Client) Request(ctx context.Context, method, endpoint string, query map[string][]string, data []byte) (json.RawMessage, error) { const contentType = "application/json" // Start measuring the request duration @@ -84,8 +84,10 @@ func (c *Client) Request(ctx context.Context, method, endpoint string, query map // Add query parameters to the URL if any if query != nil { q := u.Query() - for key, value := range query { - q.Set(key, value) + for key, values := range query { + for _, value := range values { + q.Add(key, value) + } } u.RawQuery = q.Encode() } @@ -141,3 +143,18 @@ func (c *Client) Request(ctx context.Context, method, endpoint string, query map return jsonResponse, nil } + +// TraceInProgress returns true if the trace is not finished yet. +func TraceInProgress(t *Trace) bool { + for _, outMsg := range t.Transaction.OutMsgs { + if outMsg.MsgType == MessageMsgTypeIntMsg { + return true + } + } + for _, child := range t.Children { + if TraceInProgress(&child) { + return true + } + } + return false +} diff --git a/tonapi_test.go b/tonapi_test.go index a1cd283..0729fe5 100644 --- a/tonapi_test.go +++ b/tonapi_test.go @@ -2,20 +2,81 @@ package tonapi import ( "context" + "errors" "fmt" - "net/http" - "testing" - "time" - - "github.com/go-faster/errors" + "github.com/graze/go-throttled" "github.com/stretchr/testify/require" "github.com/tonkeeper/tongo/ton" + "golang.org/x/time/rate" + "net/http" + "os" + "testing" ) var systemAccountID = ton.MustParseAccountID("Ef8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAU") +// TestThrottling tests the client with throttling. +func TestThrottling(t *testing.T) { + const ( + withTokenName = "WithToken" + withoutTokenName = "WithoutToken" + ) + tests := []struct { + name string + token string + rateLimit rate.Limit + burst int + }{ + { + name: withTokenName, + token: os.Getenv("TONAPI_TOKEN"), // use TonApi token with Lite tier + rateLimit: 10, + burst: 10, + }, + { + name: withoutTokenName, + token: "", + rateLimit: 1, + burst: 1, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + throttledClient := &http.Client{ + Transport: throttled.NewTransport( + http.DefaultTransport, + rate.NewLimiter(tt.rateLimit, tt.burst)), + } + if tt.token == "" && tt.name == withTokenName { + t.Skip("skipping test with token") + } + var client *Client + var err error + if tt.token == "" { + client, err = NewClient(TonApiURL, &Security{}, WithClient(throttledClient)) + } else { + client, err = NewClient(TonApiURL, WithToken(tt.token), WithClient(throttledClient)) + } + if err != nil { + t.Fatalf("failed to init tonapi client: %v", err) + } + for i := 0; i < 30; i++ { + _, err = client.Status(context.Background()) + require.NoError(t, err) + } + }) + } +} + +// TestCustomRequest tests the client with custom requests. func TestCustomRequest(t *testing.T) { - client, err := New() + throttledClient := &http.Client{ + Transport: throttled.NewTransport( + http.DefaultTransport, + rate.NewLimiter(1, 1)), + } + client, err := NewClient(TonApiURL, &Security{}, WithClient(throttledClient)) if err != nil { t.Fatalf("failed to init tonapi client: %v", err) } @@ -24,7 +85,7 @@ func TestCustomRequest(t *testing.T) { name string method string path string - query map[string]string + query map[string][]string err error }{ { @@ -55,7 +116,14 @@ func TestCustomRequest(t *testing.T) { name: "ok to get collections", method: http.MethodGet, path: "v2/nfts/collections", - query: map[string]string{"limit": "10"}, + query: map[string][]string{"limit": {"10"}}, + err: nil, + }, + { + name: "ok to exec get method", + method: http.MethodGet, + path: "v2/blockchain/accounts/EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs/methods/get_wallet_address", + query: map[string][]string{"args": {"UQDNzlh0XSZdb5_Qrlx5QjyZHVAO74v5oMeVVrtF_5Vt1rIt", "UQBVXzBT4lcTA3S7gxrg4hnl5fnsDKj4oNEzNp09aQxkwmCa"}}, err: nil, }, } @@ -71,7 +139,6 @@ func TestCustomRequest(t *testing.T) { require.NoError(t, err) require.NotNil(t, resp) } - time.Sleep(time.Millisecond * 100) // rps limit }) } }