diff --git a/api/openapi.json b/api/openapi.json index e4a5a945..cba4d1d1 100644 --- a/api/openapi.json +++ b/api/openapi.json @@ -2796,6 +2796,63 @@ }, "type": "array" }, + "CocoonWorkerInstance": { + "properties": { + "active_requests": { + "format": "int64", + "minimum": 0, + "type": "integer" + }, + "coefficient": { + "format": "int64", + "minimum": 0, + "type": "integer" + }, + "max_active_requests": { + "format": "int64", + "minimum": 0, + "type": "integer" + } + }, + "required": [ + "coefficient", + "active_requests", + "max_active_requests" + ], + "type": "object" + }, + "CocoonWorkerType": { + "properties": { + "name": { + "type": "string" + }, + "workers": { + "items": { + "$ref": "#/components/schemas/CocoonWorkerInstance" + }, + "type": "array" + } + }, + "required": [ + "name", + "workers" + ], + "type": "object" + }, + "CocoonWorkersResponse": { + "properties": { + "types": { + "items": { + "$ref": "#/components/schemas/CocoonWorkerType" + }, + "type": "array" + } + }, + "required": [ + "types" + ], + "type": "object" + }, "ComputePhase": { "properties": { "exit_code": { @@ -9481,6 +9538,199 @@ ] } }, + "/v2/cocoon/query": { + "post": { + "description": "Proxy arbitrary OpenAI-style JSON to Cocoon (POST)", + "operationId": "postCocoonQuery", + "parameters": [ + { + "description": "Cocoon worker model name passed to the proxy.", + "in": "query", + "name": "model", + "schema": { + "type": "string" + } + }, + { + "description": "HTTP path on the Cocoon worker (e.g. /v1/chat/completions).", + "in": "query", + "name": "path", + "schema": { + "default": "/query", + "type": "string" + } + } + ], + "requestBody": { + "content": { + "application/json": { + "schema": {} + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/json": { + "schema": {} + } + }, + "description": "Successful response" + }, + "401": { + "content": { + "application/json": { + "schema": { + "properties": { + "error": { + "properties": { + "message": { + "type": "string" + }, + "type": { + "type": "string" + } + }, + "type": "object" + } + }, + "type": "object" + } + } + }, + "description": "Unauthorized" + }, + "501": { + "content": { + "application/json": { + "schema": { + "type": "object" + } + } + }, + "description": "Not implemented" + }, + "default": { + "$ref": "#/components/responses/Error" + } + } + } + }, + "/v2/cocoon/v1/chat/completions": { + "post": { + "description": "OpenAI-compatible [Create chat completion](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create).\n", + "operationId": "postCocoonV1ChatCompletions", + "requestBody": { + "content": { + "application/json": { + "schema": {} + } + }, + "required": true + }, + "responses": { + "200": { + "content": { + "application/json": { + "schema": {} + } + }, + "description": "Successful response" + }, + "401": { + "content": { + "application/json": { + "schema": { + "properties": { + "error": { + "properties": { + "message": { + "type": "string" + }, + "type": { + "type": "string" + } + }, + "type": "object" + } + }, + "type": "object" + } + } + }, + "description": "Unauthorized" + }, + "501": { + "content": { + "application/json": { + "schema": { + "type": "object" + } + } + }, + "description": "Not implemented" + }, + "default": { + "$ref": "#/components/responses/Error" + } + } + } + }, + "/v2/cocoon/workers": { + "get": { + "description": "Cocoon worker types (same shape as gocoon Connection.GetWorkerTypes)", + "operationId": "getCocoonWorkers", + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/CocoonWorkersResponse" + } + } + }, + "description": "Successful response" + }, + "401": { + "content": { + "application/json": { + "schema": { + "properties": { + "error": { + "properties": { + "message": { + "type": "string" + }, + "type": { + "type": "string" + } + }, + "type": "object" + } + }, + "type": "object" + } + } + }, + "description": "Unauthorized" + }, + "501": { + "content": { + "application/json": { + "schema": { + "type": "object" + } + } + }, + "description": "Not implemented" + }, + "default": { + "$ref": "#/components/responses/Error" + } + } + } + }, "/v2/dns/auctions": { "get": { "description": "Get all auctions", diff --git a/api/openapi.yml b/api/openapi.yml index 6ddd03fa..0b6c8556 100644 --- a/api/openapi.yml +++ b/api/openapi.yml @@ -3131,6 +3131,128 @@ paths: $ref: "#/components/schemas/RoundRewardsResponse" 'default': $ref: '#/components/responses/Error' + /v2/cocoon/workers: + get: + operationId: getCocoonWorkers + description: Cocoon worker types (same shape as gocoon Connection.GetWorkerTypes) + responses: + '200': + description: Successful response + content: + application/json: + schema: + $ref: '#/components/schemas/CocoonWorkersResponse' + '401': + description: Unauthorized + content: + application/json: + schema: + type: object + properties: + error: + type: object + properties: + message: + type: string + type: + type: string + '501': + description: Not implemented + content: + application/json: + schema: + type: object + 'default': + $ref: '#/components/responses/Error' + + /v2/cocoon/query: + post: + operationId: postCocoonQuery + description: Proxy arbitrary OpenAI-style JSON to Cocoon (POST) + parameters: + - name: model + in: query + description: Cocoon worker model name passed to the proxy. + schema: + type: string + - name: path + in: query + description: HTTP path on the Cocoon worker (e.g. /v1/chat/completions). + schema: + type: string + default: "/query" + requestBody: + required: true + content: + application/json: + schema: { } # Free-form JSON value + responses: + '200': + description: Successful response + content: + application/json: + schema: { } # Free-form JSON value + '401': + description: Unauthorized + content: + application/json: + schema: + type: object + properties: + error: + type: object + properties: + message: + type: string + type: + type: string + '501': + description: Not implemented + content: + application/json: + schema: + type: object + 'default': + $ref: '#/components/responses/Error' + + /v2/cocoon/v1/chat/completions: + post: + operationId: postCocoonV1ChatCompletions + description: | + OpenAI-compatible [Create chat completion](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create). + requestBody: + required: true + content: + application/json: + schema: { } # OpenAI-style chat completion request + responses: + '200': + description: Successful response + content: + application/json: + schema: { } # OpenAI-style chat completion response + '401': + description: Unauthorized + content: + application/json: + schema: + type: object + properties: + error: + type: object + properties: + message: + type: string + type: + type: string + '501': + description: Not implemented + content: + application/json: + schema: + type: object + 'default': + $ref: '#/components/responses/Error' components: parameters: masterchainSeqno: @@ -3704,6 +3826,46 @@ components: error: type: string example: error description + CocoonWorkerInstance: + type: object + required: + - coefficient + - active_requests + - max_active_requests + properties: + coefficient: + type: integer + format: int64 + minimum: 0 + active_requests: + type: integer + format: int64 + minimum: 0 + max_active_requests: + type: integer + format: int64 + minimum: 0 + CocoonWorkerType: + type: object + required: + - name + - workers + properties: + name: + type: string + workers: + type: array + items: + $ref: '#/components/schemas/CocoonWorkerInstance' + CocoonWorkersResponse: + type: object + required: + - types + properties: + types: + type: array + items: + $ref: '#/components/schemas/CocoonWorkerType' AccountAddress: type: object required: diff --git a/go.mod b/go.mod index 5c2dd1d7..8fdb352d 100644 --- a/go.mod +++ b/go.mod @@ -24,17 +24,17 @@ require ( github.com/shopspring/decimal v1.4.0 github.com/sourcegraph/conc v0.3.0 github.com/stretchr/testify v1.11.1 + github.com/tonkeeper/gocoon v1.0.3 github.com/tonkeeper/scam_backoffice_rules v0.0.11 - github.com/tonkeeper/tongo v1.19.0 + github.com/tonkeeper/tongo v1.19.1-0.20260417135212-97ef83ef6640 go.opentelemetry.io/otel v1.43.0 go.opentelemetry.io/otel/metric v1.43.0 go.opentelemetry.io/otel/trace v1.43.0 - go.uber.org/multierr v1.11.0 go.uber.org/zap v1.27.1 - golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90 - golang.org/x/net v0.52.0 + golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f + golang.org/x/net v0.53.0 golang.org/x/sync v0.20.0 - golang.org/x/text v0.35.0 + golang.org/x/text v0.36.0 google.golang.org/grpc v1.80.0 gopkg.in/yaml.v3 v3.0.1 ) @@ -62,11 +62,12 @@ require ( github.com/valyala/bytebufferpool v1.0.0 // indirect github.com/valyala/fasttemplate v1.2.2 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect + go.uber.org/multierr v1.11.0 // indirect go.yaml.in/yaml/v2 v2.4.4 // indirect - golang.org/x/crypto v0.49.0 // indirect - golang.org/x/mod v0.34.0 // indirect - golang.org/x/sys v0.42.0 // indirect - golang.org/x/tools v0.43.0 // indirect + golang.org/x/crypto v0.50.0 // indirect + golang.org/x/mod v0.35.0 // indirect + golang.org/x/sys v0.43.0 // indirect + golang.org/x/tools v0.44.0 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9 // indirect google.golang.org/protobuf v1.36.11 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect diff --git a/go.sum b/go.sum index 00a2596a..0414f702 100644 --- a/go.sum +++ b/go.sum @@ -1,6 +1,3 @@ -github.com/BurntSushi/toml v1.0.0/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= -github.com/BurntSushi/toml v1.2.1 h1:9F2/+DoOYIOksmaJFPw1tGFy1eDnIJXg+UHjuD8lTak= -github.com/BurntSushi/toml v1.2.1/go.mod h1:CxXYINrC8qIiEnFrOxCa7Jy5BFHlXnUU2pbicEuybxQ= github.com/BurntSushi/toml v1.6.0 h1:dRaEfpa2VI55EwlIW72hMRHdWouJeRF7TPYhI+AUQjk= github.com/BurntSushi/toml v1.6.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho= github.com/Code-Hex/go-generics-cache v1.5.1 h1:6vhZGc5M7Y/YD8cIUcY8kcuQLB4cHR7U+0KMqAA0KcU= @@ -15,19 +12,12 @@ github.com/caarlos0/env/v6 v6.10.1 h1:t1mPSxNpei6M5yAeu1qtRdPAK29Nbcf/n3G7x+b3/I github.com/caarlos0/env/v6 v6.10.1/go.mod h1:hvp/ryKXKipEkcuYjs9mI4bBCg+UI0Yhgm5Zu0ddvwc= github.com/cespare/xxhash/v2 v2.3.0 h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= -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.11.0 h1:G/nrcoOa7ZXlpoa/91N3X7mM3r8eIlMBBJZvsz/mxKI= -github.com/dlclark/regexp2 v1.11.0/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= github.com/dlclark/regexp2 v1.11.5 h1:Q/sSnsKerHeCkc/jSTNq1oCm7KiVgUMZRDUoRu0JQZQ= github.com/dlclark/regexp2 v1.11.5/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cnmRbL6yW8= -github.com/fatih/color v1.16.0 h1:zmkK9Ngbjj+K0yRhTVONQh1p/HknKYSlNT+vZCzyokM= -github.com/fatih/color v1.16.0/go.mod h1:fL2Sau1YI5c0pdGEVCbKQbLXB6edEj1ZgiY4NijnWvE= github.com/fatih/color v1.19.0 h1:Zp3PiM21/9Ld6FzSKyL5c/BULoe/ONr9KlbYVOfG8+w= github.com/fatih/color v1.19.0/go.mod h1:zNk67I0ZUT1bEGsSGyCZYZNrHuTkJJB+r6Q9VuMi0LE= -github.com/getsentry/sentry-go v0.24.1 h1:W6/0GyTy8J6ge6lVCc94WB6Gx2ZuLrgopnn9w8Hiwuk= -github.com/getsentry/sentry-go v0.24.1/go.mod h1:lc76E2QywIyW8WuBnwl8Lc4bkmQH4+w1gwTf25trprY= github.com/getsentry/sentry-go v0.44.1 h1:/cPtrA5qB7uMRrhgSn9TYtcEF36auGP3Y6+ThvD/yaI= github.com/getsentry/sentry-go v0.44.1/go.mod h1:XDotiNZbgf5U8bPDUAfvcFmOnMQQceESxyKaObSssW0= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= @@ -36,8 +26,6 @@ github.com/go-errors/errors v1.4.2 h1:J6MZopCL4uSllY1OfXM374weqZFFItUbrImctkmUxI github.com/go-errors/errors v1.4.2/go.mod h1:sIVyrIiJhuEF+Pj9Ebtd6P/rEYROXFi3BopGUQ5a5Og= 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/jx v1.2.0 h1:T2YHJPrFaYu21fJtUxC9GzmluKu8rVIFDwwGBKTDseI= github.com/go-faster/jx v1.2.0/go.mod h1:UWLOVDmMG597a5tBFPLIWJdUxz5/2emOpfsj9Neg0PE= github.com/go-faster/yaml v0.4.6 h1:lOK/EhI04gCpPgPhgt0bChS6bvw7G3WwI8xxVe0sw9I= @@ -53,48 +41,34 @@ github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= 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/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg= github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= github.com/graph-gophers/dataloader/v7 v7.1.3 h1:mXCI1E3dBG0aG1Tzg1tXaz+nN140opFIgEfYhxHR0XA= github.com/graph-gophers/dataloader/v7 v7.1.3/go.mod h1:cnjGvZ3DuN2hU90Q72WCZNzkCEq/BHwh7fI7w7/GhIg= github.com/hashicorp/golang-lru/v2 v2.0.7 h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= github.com/hashicorp/golang-lru/v2 v2.0.7/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= -github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo= -github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ= github.com/klauspost/compress v1.18.2 h1:iiPHWW0YrcFgpBYhsA6D1+fqHssJscY/Tm/y2Uqnapk= +github.com/klauspost/compress v1.18.2/go.mod h1:R0h/fSBs8DE4ENlcrlib3PsXS61voFxhIs2DeRhCvJ4= 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= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= -github.com/labstack/gommon v0.4.0 h1:y7cvthEAEbU0yHOf4axH8ZG2NH8knB9iNSoTO8dyIk8= -github.com/labstack/gommon v0.4.0/go.mod h1:uW6kP17uPlLJsD3ijUYn3/M5bAxtlZhMI6m3MFxTMTM= github.com/labstack/gommon v0.4.2 h1:F8qTUNXgG1+6WQmqoUWnz8WiEU60mXVVw0P4ht1WRA0= github.com/labstack/gommon v0.4.2/go.mod h1:QlUFxVM+SNXhDL/Z7YhocGIBYOiwB0mXm1+1bAPHPyU= -github.com/mattn/go-colorable v0.1.11/go.mod h1:u5H1YNBxpqRaxsYJYSkiCWKzEfiAb1Gb520KVy5xxl4= -github.com/mattn/go-colorable v0.1.13 h1:fFA4WZxdEF4tXPZVKMLwD8oUnCTTo08duU7wxecdEvA= -github.com/mattn/go-colorable v0.1.13/go.mod h1:7S9/ev0klgBDR4GtXTXX8a3vIGJpMovkB8vQcUbaXHg= github.com/mattn/go-colorable v0.1.14 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIE= github.com/mattn/go-colorable v0.1.14/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= -github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= -github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mozillazg/go-unidecode v0.2.0 h1:vFGEzAH9KSwyWmXCOblazEWDh7fOkpmy/Z4ArmamSUc= github.com/mozillazg/go-unidecode v0.2.0/go.mod h1:zB48+/Z5toiRolOZy9ksLryJ976VIwmDmpQ2quyt1aA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= -github.com/nicksnyder/go-i18n/v2 v2.2.1 h1:aOzRCdwsJuoExfZhoiXHy4bjruwCMdt5otbYojM/PaA= -github.com/nicksnyder/go-i18n/v2 v2.2.1/go.mod h1:fF2++lPHlo+/kPaj3nB0uxtPwzlPm+BlgwGX7MkeGj0= github.com/nicksnyder/go-i18n/v2 v2.6.1 h1:JDEJraFsQE17Dut9HFDHzCoAWGEQJom5s0TRd17NIEQ= github.com/nicksnyder/go-i18n/v2 v2.6.1/go.mod h1:Vee0/9RD3Quc/NmwEjzzD7VTZ+Ir7QbXocrkhOzmUKA= github.com/oasisprotocol/curve25519-voi v0.0.0-20251114093237-2ab5a27a1729 h1:yfQ2sO9WJXUAIUR+g7NUkxJSKCAFJcR5sUDu+ZmjTZI= github.com/oasisprotocol/curve25519-voi v0.0.0-20251114093237-2ab5a27a1729/go.mod h1:hVoHR2EVESiICEMbg137etN/Lx+lSrHPTD39Z/uE+2s= -github.com/ogen-go/ogen v1.0.0 h1:n1hkgOnLtA1Xn369KAzJhqzphQzNo/wAI82NIaFQNXA= -github.com/ogen-go/ogen v1.0.0/go.mod h1:NFn616zR+/DPsq8rPoezaHlhKcNQzlYfo5gUieW8utI= github.com/ogen-go/ogen v1.20.2 h1:mEZGPST7ZeX84AkqRlFawDLwcwuzcLO5PtYpAXLT1YE= github.com/ogen-go/ogen v1.20.2/go.mod h1:sJ1pJVp4S1RcSZlYIiMLo0QSMSt2pls4zfrc+hNKnzk= github.com/pingcap/errors v0.11.4 h1:lFuQV/oaUMGcD2tqt+01ROSmJs75VG1ToEOkZIZ4nE4= @@ -107,140 +81,77 @@ github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= -github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs= -github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA= github.com/prometheus/common v0.67.5 h1:pIgK94WWlQt1WLwAC5j2ynLaBRDiinoAb86HZHTUGI4= github.com/prometheus/common v0.67.5/go.mod h1:SjE/0MzDEEAyrdr5Gqc6G+sXI67maCxzaT3A2+HqjUw= -github.com/prometheus/procfs v0.16.1 h1:hZ15bTNuirocR6u0JZ6BAHHmwS1p8B4P6MRqxtzMyRg= -github.com/prometheus/procfs v0.16.1/go.mod h1:teAbpZRB1iIAJYREa1LsoWUXykVXA1KlTmWl8x/U+Is= github.com/prometheus/procfs v0.20.1 h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEycfc= github.com/prometheus/procfs v0.20.1/go.mod h1:o9EMBZGRyvDrSPH1RqdxhojkuXstoe4UlK79eF5TGGo= -github.com/puzpuzpuz/xsync/v2 v2.4.0 h1:5sXAMHrtx1bg9nbRZTOn8T4MkWe5V+o8yKRH02Eznag= -github.com/puzpuzpuz/xsync/v2 v2.4.0/go.mod h1:gD2H2krq/w52MfPLE+Uy64TzJDVY7lP2znR9qmR35kU= github.com/puzpuzpuz/xsync/v2 v2.5.1 h1:mVGYAvzDSu52+zaGyNjC+24Xw2bQi3kTr4QJ6N9pIIU= github.com/puzpuzpuz/xsync/v2 v2.5.1/go.mod h1:gD2H2krq/w52MfPLE+Uy64TzJDVY7lP2znR9qmR35kU= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= -github.com/segmentio/asm v1.2.0 h1:9BQrFxC+YOHJlTlHGkTrFWf59nbL3XnCoFLTwDCI7ys= -github.com/segmentio/asm v1.2.0/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs= github.com/segmentio/asm v1.2.1 h1:DTNbBqs57ioxAD4PrArqftgypG4/qNpXoJx8TVXxPR0= github.com/segmentio/asm v1.2.1/go.mod h1:BqMnlJP91P8d+4ibuonYZw9mfnzI9HfxselHZr5aAcs= -github.com/shopspring/decimal v1.3.1 h1:2Usl1nmF/WZucqkFZhnfFYxxxu8LG21F6nPQBE5gKV8= -github.com/shopspring/decimal v1.3.1/go.mod h1:DKyhrW/HYNuLGql+MJL6WCR6knT2jwCFRcu2hWCYk4o= github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k= github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME= 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/sourcegraph/conc v0.3.0 h1:OQTbbt6P72L20UqAkXXuLOj79LfEanQ+YQFNpLA9ySo= github.com/sourcegraph/conc v0.3.0/go.mod h1:Sdozi7LEKbFPqYX2/J+iBAM6HpqSLTASQIKqDmF7Mt0= -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.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= +github.com/tonkeeper/gocoon v0.0.0-20260418091633-712b860c1b01 h1:nHpkyYsB29pgSftH5ppt0yK0XTggw3ziJpYJbPjMIw4= +github.com/tonkeeper/gocoon v0.0.0-20260418091633-712b860c1b01/go.mod h1:VbjDK6sCA/fsbvdgGjMWs1Xt2hPehA3uP2MTPSY2Ag4= +github.com/tonkeeper/gocoon v1.0.1 h1:h9LDzqwwNLJU8to7x89GaIUHuZ0jL40UpX9rJ2veZLU= +github.com/tonkeeper/gocoon v1.0.1/go.mod h1:VbjDK6sCA/fsbvdgGjMWs1Xt2hPehA3uP2MTPSY2Ag4= +github.com/tonkeeper/gocoon v1.0.2 h1:rsV8VP0LsGhgdk/RV2vcnkKTEvSVF3NYqVuTFhZAKYg= +github.com/tonkeeper/gocoon v1.0.2/go.mod h1:VbjDK6sCA/fsbvdgGjMWs1Xt2hPehA3uP2MTPSY2Ag4= +github.com/tonkeeper/gocoon v1.0.3 h1:LZgxfnEBH4DSCKzFo5P2yznMzzeipWLqRgzumQ9CGfQ= +github.com/tonkeeper/gocoon v1.0.3/go.mod h1:VbjDK6sCA/fsbvdgGjMWs1Xt2hPehA3uP2MTPSY2Ag4= github.com/tonkeeper/scam_backoffice_rules v0.0.11 h1:VXbNNyTO49OArvQwPRCU+1WUEyfQgkqG7Q8NVhQ7320= github.com/tonkeeper/scam_backoffice_rules v0.0.11/go.mod h1:SqZXYO9vbID8ku+xnnaKXeNGmehxigODGrk5V1KqbRA= -github.com/tonkeeper/tongo v1.18.4 h1:R5OvAvthY5bE/2ROF7/ni07tmOAPBWHlPHIjrS4Kh7g= -github.com/tonkeeper/tongo v1.18.4/go.mod h1:nHmdEXPfT0/EvkEaBzPiY599/0OYjQSW4dWR7aX+OII= -github.com/tonkeeper/tongo v1.18.5-0.20260414170540-4a73e4b7f8a4 h1:j0tAEZF4M8Ftrt6B8OG5qGlGvGD7W07MBbx29ZA+jtg= -github.com/tonkeeper/tongo v1.18.5-0.20260414170540-4a73e4b7f8a4/go.mod h1:nHmdEXPfT0/EvkEaBzPiY599/0OYjQSW4dWR7aX+OII= -github.com/tonkeeper/tongo v1.19.0 h1:ZX+vvTQPH20MvoWSrjQnSDWpZ+v2CaGipj+M6ga93Fk= -github.com/tonkeeper/tongo v1.19.0/go.mod h1:nHmdEXPfT0/EvkEaBzPiY599/0OYjQSW4dWR7aX+OII= +github.com/tonkeeper/tongo v1.19.1-0.20260417135212-97ef83ef6640 h1:U4npFMpt3aY4TZcM6v3+0OUxJvHMxo3j5WdAZydtaag= +github.com/tonkeeper/tongo v1.19.1-0.20260417135212-97ef83ef6640/go.mod h1:nHmdEXPfT0/EvkEaBzPiY599/0OYjQSW4dWR7aX+OII= github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw= github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc= -github.com/valyala/fasttemplate v1.2.1/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ= github.com/valyala/fasttemplate v1.2.2 h1:lxLXG0uE3Qnshl9QyaK6XJxMXlQZELvChBOCmQD0Loo= github.com/valyala/fasttemplate v1.2.2/go.mod h1:KHLXt3tVN2HBp8eijSv/kGJopbvo7S+qRAEEKiv+SiQ= -github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= -go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8= -go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM= go.opentelemetry.io/otel v1.43.0 h1:mYIM03dnh5zfN7HautFE4ieIig9amkNANT+xcVxAj9I= go.opentelemetry.io/otel v1.43.0/go.mod h1:JuG+u74mvjvcm8vj8pI5XiHy1zDeoCS2LB1spIq7Ay0= -go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA= -go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI= go.opentelemetry.io/otel/metric v1.43.0 h1:d7638QeInOnuwOONPp4JAOGfbCEpYb+K6DVWvdxGzgM= go.opentelemetry.io/otel/metric v1.43.0/go.mod h1:RDnPtIxvqlgO8GRW18W6Z/4P462ldprJtfxHxyKd2PY= -go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE= -go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs= go.opentelemetry.io/otel/trace v1.43.0 h1:BkNrHpup+4k4w+ZZ86CZoHHEkohws8AY+WTX09nk+3A= go.opentelemetry.io/otel/trace v1.43.0/go.mod h1:/QJhyVBUUswCphDVxq+8mld+AvhXZLhe+8WVFxiFff0= 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.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= -go.uber.org/zap v1.27.0/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= go.uber.org/zap v1.27.1 h1:08RqriUEv8+ArZRYSTXy1LeBScaMpVSTBhCeaZYfMYc= go.uber.org/zap v1.27.1/go.mod h1:GB2qFLM7cTU87MWRP2mPIjqfIDnGu+VIO4V/SdhGo2E= -go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI= -go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= -golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= -golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= -golang.org/x/crypto v0.48.0 h1:/VRzVqiRSggnhY7gNRxPauEQ5Drw9haKdM0jqfcCFts= -golang.org/x/crypto v0.48.0/go.mod h1:r0kV5h3qnFPlQnBSrULhlsRfryS2pmewsg+XfMgkVos= -golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4= -golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA= -golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa h1:Zt3DZoOFFYkKhDT3v7Lm9FDMEV06GpzjG2jrqW+QTE0= -golang.org/x/exp v0.0.0-20260218203240-3dfff04db8fa/go.mod h1:K79w1Vqn7PoiZn+TkNpx3BUWUQksGO3JcVX6qIjytmA= -golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90 h1:jiDhWWeC7jfWqR9c/uplMOqJ0sbNlNWv0UkzE0vX1MA= -golang.org/x/exp v0.0.0-20260312153236-7ab1446f8b90/go.mod h1:xE1HEv6b+1SCZ5/uscMRjUBKtIxworgEcEi+/n9NQDQ= -golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8= -golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w= -golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI= -golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY= -golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= -golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.50.0 h1:ucWh9eiCGyDR3vtzso0WMQinm2Dnt8cFMuQa9K33J60= -golang.org/x/net v0.50.0/go.mod h1:UgoSli3F/pBgdJBHCTc+tp3gmrU4XswgGRgtnwWTfyM= -golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0= -golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw= -golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.19.0 h1:vV+1eWNmZ5geRlYjzm2adRgW2/mcpevXNg50YZtPCE4= -golang.org/x/sync v0.19.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI= +go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= +go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= +golang.org/x/crypto v0.50.0 h1:zO47/JPrL6vsNkINmLoo/PH1gcxpls50DNogFvB5ZGI= +golang.org/x/crypto v0.50.0/go.mod h1:3muZ7vA7PBCE6xgPX7nkzzjiUq87kRItoJQM1Yo8S+Q= +golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f h1:W3F4c+6OLc6H2lb//N1q4WpJkhzJCK5J6kUi1NTVXfM= +golang.org/x/exp v0.0.0-20260410095643-746e56fc9e2f/go.mod h1:J1xhfL/vlindoeF/aINzNzt2Bket5bjo9sdOYzOsU80= +golang.org/x/mod v0.35.0 h1:Ww1D637e6Pg+Zb2KrWfHQUnH2dQRLBQyAtpr/haaJeM= +golang.org/x/mod v0.35.0/go.mod h1:+GwiRhIInF8wPm+4AoT6L0FA1QWAad3OMdTRx4tFYlU= +golang.org/x/net v0.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA= +golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs= golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4= golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= -golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20210927094055-39ccf1dd6fa6/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20211103235746-7861aae1554b/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -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.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k= -golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks= -golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo= -golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= -golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.4.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.34.0 h1:oL/Qq0Kdaqxa1KbNeMKwQq0reLCCaFtqu2eNuSeNHbk= -golang.org/x/text v0.34.0/go.mod h1:homfLqTYRFyVYemLBFl5GgL/DWEiH5wcsQ5gSh1yziA= -golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8= -golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= -golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= -golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k= -golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0= -golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s= -golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0= -golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI= +golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= +golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg= +golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164= +golang.org/x/tools v0.44.0 h1:UP4ajHPIcuMjT1GqzDWRlalUEoY+uzoZKnhOjbIPD2c= +golang.org/x/tools v0.44.0/go.mod h1:KA0AfVErSdxRZIsOVipbv3rQhVXTnlU6UhKxHd1seDI= google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9 h1:m8qni9SQFH0tJc1X0vmnpw/0t+AImlSvp30sEupozUg= google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= -google.golang.org/grpc v1.77.0 h1:wVVY6/8cGA6vvffn+wWK5ToddbgdU3d8MNENr4evgXM= -google.golang.org/grpc v1.77.0/go.mod h1:z0BY1iVj0q8E1uSQCjL9cppRj+gnZjzDnzV0dHhrNig= google.golang.org/grpc v1.80.0 h1:Xr6m2WmWZLETvUNvIUmeD5OAagMw3FiKmMlTdViWsHM= google.golang.org/grpc v1.80.0/go.mod h1:ho/dLnxwi3EDJA4Zghp7k2Ec1+c2jqup0bFkw07bwF4= google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= @@ -248,10 +159,7 @@ google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= diff --git a/pkg/api/cocoon_handlers.go b/pkg/api/cocoon_handlers.go new file mode 100644 index 00000000..57a7f0ba --- /dev/null +++ b/pkg/api/cocoon_handlers.go @@ -0,0 +1,216 @@ +package api + +import ( + "bufio" + "bytes" + "context" + "encoding/json" + "fmt" + "io" + "net/http" + + "github.com/go-faster/jx" + "github.com/tonkeeper/gocoon" + "go.uber.org/zap" + + "github.com/tonkeeper/opentonapi/pkg/oas" +) + +const ( + cocoonPoolRetries = 5 + cocoonPoolMaxAttempts = 1 + cocoonPoolRetries +) + +func cocoonResponseAsJSON(resp []byte) ([]byte, error) { + if len(resp) == 0 { + return nil, fmt.Errorf("empty cocoon response") + } + trim := bytes.TrimLeft(resp, " \t\r\n") + body := resp + if bytes.HasPrefix(trim, []byte("HTTP/")) { + httpRes, err := http.ReadResponse(bufio.NewReader(bytes.NewReader(resp)), nil) + if err != nil { + return nil, fmt.Errorf("parse cocoon http response: %w", err) + } + defer httpRes.Body.Close() + b, err := io.ReadAll(httpRes.Body) + if err != nil { + return nil, err + } + body = bytes.TrimSpace(b) + } else { + i := bytes.IndexFunc(trim, func(c rune) bool { return c == '{' || c == '[' }) + if i < 0 { + return nil, fmt.Errorf("no JSON value in cocoon response") + } + off := len(resp) - len(trim) + i + body = bytes.TrimSpace(resp[off:]) + } + body = bytes.TrimPrefix(body, []byte{0xEF, 0xBB, 0xBF}) + dec := json.NewDecoder(bytes.NewReader(body)) + var out json.RawMessage + if err := dec.Decode(&out); err != nil { + return nil, fmt.Errorf("cocoon response is not valid JSON: %w", err) + } + return []byte(out), nil +} + +func mergeCocoonModelIntoBody(req jx.Raw, modelQuery oas.OptString) (body []byte, model string) { + body = []byte(req) + if len(body) == 0 { + body = []byte("{}") + } + model = "" + if modelQuery.Set { + model = modelQuery.Value + } + var obj map[string]any + if err := json.Unmarshal(body, &obj); err == nil && obj != nil { + if model != "" { + obj["model"] = model + } else if s, ok := obj["model"].(string); ok { + model = s + } + if b, err := json.Marshal(obj); err == nil { + body = b + } + } + return body, model +} + +func parseCocoonChatCompletionUsage(body []byte) (tokens int64, cost int64, ok bool) { + var root struct { + Usage *struct { + TotalTokens int64 `json:"total_tokens"` + TotalCost int64 `json:"total_cost"` + } `json:"usage"` + } + if err := json.Unmarshal(body, &root); err != nil || root.Usage == nil { + return 0, 0, false + } + if root.Usage.TotalTokens <= 0 || root.Usage.TotalCost <= 0 { + return 0, 0, false + } + return root.Usage.TotalTokens, root.Usage.TotalCost, true +} + +func (h *Handler) recordCocoonChatCompletionUsage(ctx context.Context, jsonBody []byte) { + if h.tonConsole == nil { + return + } + tokens, cost, ok := parseCocoonChatCompletionUsage(jsonBody) + if !ok { + return + } + if err := h.tonConsole.CreateCocoonUsageEvent(ctx, tokens, cost); err != nil { + h.logger.Warn("cocoon usage event", zap.Error(err)) + } +} + +func (h *Handler) PostCocoonQuery(ctx context.Context, req jx.Raw, params oas.PostCocoonQueryParams) (oas.PostCocoonQueryRes, error) { + //if h.cocoonPool == nil { + // return &oas.PostCocoonQueryNotImplemented{}, nil + //} + //body, model := mergeCocoonModelIntoBody(req, params.Model) + //conn, err := h.cocoonPool.pick(ctx) + //if err != nil { + // return nil, toError(http.StatusInternalServerError, err) + //} + //respBody, err := conn.POST(ctx, model, params.Path.Value, body) + //if err != nil { + // return nil, toError(http.StatusBadGateway, err) + //} + //jsonBody, err := cocoonResponseAsJSON(respBody) + //if err != nil { + // return nil, toError(http.StatusBadGateway, err) + //} + //ok := oas.PostCocoonQueryOKApplicationJSON(jx.Raw(jsonBody)) + //return &ok, nil + return &oas.PostCocoonQueryNotImplemented{}, nil +} + +func (h *Handler) PostCocoonV1ChatCompletions(ctx context.Context, req jx.Raw) (oas.PostCocoonV1ChatCompletionsRes, error) { + if h.cocoonPool == nil { + return &oas.PostCocoonV1ChatCompletionsNotImplemented{}, nil + } + body, model := mergeCocoonModelIntoBody(req, oas.OptString{}) + const upstreamPath = "/v1/chat/completions" + var jsonBody []byte + var lastErr error + lastFailedPick := false + for attempt := 0; attempt < cocoonPoolMaxAttempts; attempt++ { + conn, err := h.cocoonPool.pick(ctx) + if err != nil { + lastErr = err + lastFailedPick = true + fmt.Println("cocoon pick error: ", err) + continue + } + lastFailedPick = false + respBody, err := conn.POST(ctx, model, upstreamPath, body) + if err != nil { + lastErr = err + fmt.Println("cocoon error POST: ", err) + continue + } + jsonBody, err = cocoonResponseAsJSON(respBody) + if err != nil { + lastErr = err + fmt.Println("cocoon json error: ", err) + continue + } + ok := oas.PostCocoonV1ChatCompletionsOKApplicationJSON(jx.Raw(jsonBody)) + h.recordCocoonChatCompletionUsage(ctx, jsonBody) + return &ok, nil + } + if lastFailedPick { + return nil, toError(http.StatusInternalServerError, lastErr) + } + return nil, toError(http.StatusBadGateway, lastErr) +} + +func (h *Handler) GetCocoonWorkers(ctx context.Context) (oas.GetCocoonWorkersRes, error) { + if h.cocoonPool == nil { + return &oas.GetCocoonWorkersNotImplemented{}, nil + } + var types []gocoon.WorkerType + var lastErr error + lastFailedPick := false + for attempt := 0; attempt < cocoonPoolMaxAttempts; attempt++ { + conn, err := h.cocoonPool.pick(ctx) + if err != nil { + lastErr = err + lastFailedPick = true + fmt.Println("cocoon pick error: ", err) + continue + } + lastFailedPick = false + types, err = conn.GetWorkerTypes(ctx) + if err != nil { + lastErr = err + fmt.Println("cocoon GetWorkerTypes error: ", err) + continue + } + return workerTypesToResponse(types), nil + } + if lastFailedPick { + return nil, toError(http.StatusInternalServerError, lastErr) + } + return nil, toError(http.StatusBadGateway, lastErr) +} + +func workerTypesToResponse(types []gocoon.WorkerType) *oas.CocoonWorkersResponse { + out := make([]oas.CocoonWorkerType, 0, len(types)) + for _, wt := range types { + ws := make([]oas.CocoonWorkerInstance, 0, len(wt.Workers)) + for _, w := range wt.Workers { + ws = append(ws, oas.CocoonWorkerInstance{ + Coefficient: int64(w.Coefficient), + ActiveRequests: int64(w.ActiveRequests), + MaxActiveRequests: int64(w.MaxActiveRequests), + }) + } + out = append(out, oas.CocoonWorkerType{Name: wt.Name, Workers: ws}) + } + return &oas.CocoonWorkersResponse{Types: out} +} diff --git a/pkg/api/cocoon_pool.go b/pkg/api/cocoon_pool.go new file mode 100644 index 00000000..6421213d --- /dev/null +++ b/pkg/api/cocoon_pool.go @@ -0,0 +1,108 @@ +package api + +import ( + "context" + "math/rand/v2" + "sync" + "time" + + "github.com/tonkeeper/gocoon" + "go.uber.org/zap" +) + +const defaultCocoonPoolRefreshInterval = 5 * time.Minute + +type CocoonDialer interface { + Connect(ctx context.Context, logger *zap.Logger) (*gocoon.Connection, error) +} + +type CocoonPool struct { + mu sync.RWMutex + size int + client CocoonDialer + logger *zap.Logger + conns []*gocoon.Connection + refreshInterval time.Duration +} + +func NewCocoonPool(client CocoonDialer, logger *zap.Logger, size int, refreshInterval time.Duration) *CocoonPool { + if size <= 0 { + size = 3 + } + if refreshInterval <= 0 { + refreshInterval = defaultCocoonPoolRefreshInterval + } + return &CocoonPool{ + client: client, + logger: logger, + size: size, + conns: make([]*gocoon.Connection, size), + refreshInterval: refreshInterval, + } +} + +func (p *CocoonPool) StartAsync() { + for slot := range p.size { + go p.fillSlot(slot) + } + if p.logger != nil { + p.logger.Info("cocoon pool: periodic connection refresh", zap.Duration("interval", p.refreshInterval)) + } + go p.refreshLoop() +} + +func (p *CocoonPool) refreshLoop() { + t := time.NewTicker(p.refreshInterval) + defer t.Stop() + for range t.C { + p.mu.Lock() + for i := range p.conns { + if c := p.conns[i]; c != nil { + _ = c.Close() + p.conns[i] = nil + } + } + p.mu.Unlock() + if p.logger != nil { + p.logger.Info("cocoon pool: closing all connections for refresh") + } + for slot := range p.size { + go p.fillSlot(slot) + } + } +} + +func (p *CocoonPool) fillSlot(slot int) { + ctx := context.Background() + conn, err := p.client.Connect(ctx, p.logger) + if err != nil { + if p.logger != nil { + p.logger.Warn("cocoon pool: connect failed", zap.Int("slot", slot), zap.Error(err)) + } + return + } + p.mu.Lock() + if old := p.conns[slot]; old != nil { + _ = old.Close() + } + p.conns[slot] = conn + p.mu.Unlock() + if p.logger != nil { + p.logger.Info("cocoon pool: connection ready", zap.Int("slot", slot)) + } +} + +func (p *CocoonPool) pick(ctx context.Context) (*gocoon.Connection, error) { + p.mu.RLock() + ready := make([]*gocoon.Connection, 0, p.size) + for _, c := range p.conns { + if c != nil { + ready = append(ready, c) + } + } + p.mu.RUnlock() + if len(ready) > 0 { + return ready[rand.IntN(len(ready))], nil + } + return p.client.Connect(ctx, p.logger) +} diff --git a/pkg/api/handler.go b/pkg/api/handler.go index 82e0a06d..47016b3b 100644 --- a/pkg/api/handler.go +++ b/pkg/api/handler.go @@ -74,6 +74,8 @@ type Handler struct { mu sync.Mutex dns *dns.DNS // todo: update when blockchain config changes configPool *sync.Pool + cocoonPool *CocoonPool + tonConsole TonConsole } func (h *Handler) NewError(ctx context.Context, err error) *oas.ErrorStatusCode { @@ -97,6 +99,8 @@ type Options struct { score scoreSource parallelTraceProcessing bool rewardsLiteServers []config.LiteServer + cocoonPool *CocoonPool + tonConsole TonConsole } type Option func(o *Options) @@ -190,6 +194,18 @@ func WithRewards(s []config.LiteServer) Option { } } +func WithCocoonPool(pool *CocoonPool) Option { + return func(o *Options) { + o.cocoonPool = pool + } +} + +func WithTonConsole(w TonConsole) Option { + return func(o *Options) { + o.tonConsole = w + } +} + func NewHandler(logger *zap.Logger, opts ...Option) (*Handler, error) { options := &Options{} for _, o := range opts { @@ -287,6 +303,8 @@ func NewHandler(logger *zap.Logger, opts ...Option) (*Handler, error) { tonConnect: tonConnect, configPool: configPool, rewards: rwd, + cocoonPool: options.cocoonPool, + tonConsole: options.tonConsole, }, nil } diff --git a/pkg/api/interfaces.go b/pkg/api/interfaces.go index 4e8529fe..1aea4c26 100644 --- a/pkg/api/interfaces.go +++ b/pkg/api/interfaces.go @@ -215,6 +215,10 @@ type verifierSource interface { GetAccountSource(accountID ton.AccountID) (verifier.Source, error) } +type TonConsole interface { + CreateCocoonUsageEvent(ctx context.Context, tokensSpent int64, totalCost int64) error +} + type metadataCache struct { collectionsCache cache.Cache[tongo.AccountID, tep64.Metadata] jettonsCache cache.Cache[tongo.AccountID, tep64.Metadata] diff --git a/pkg/oas/oas_client_gen.go b/pkg/oas/oas_client_gen.go index ed0ed501..6f3eb922 100644 --- a/pkg/oas/oas_client_gen.go +++ b/pkg/oas/oas_client_gen.go @@ -345,6 +345,12 @@ type Invoker interface { // // GET /v2/rates/chart GetChartRates(ctx context.Context, params GetChartRatesParams) (*GetChartRatesOK, error) + // GetCocoonWorkers invokes getCocoonWorkers operation. + // + // Cocoon worker types (same shape as gocoon Connection.GetWorkerTypes). + // + // GET /v2/cocoon/workers + GetCocoonWorkers(ctx context.Context) (GetCocoonWorkersRes, error) // GetDnsInfo invokes getDnsInfo operation. // // Get full information about domain name. @@ -686,6 +692,19 @@ type Invoker interface { // // POST /v2/pubkeys/wallets/_bulk GetWalletsByPublicKeyBulk(ctx context.Context, request OptGetWalletsByPublicKeyBulkReq) (*WalletsByPublicKeys, error) + // PostCocoonQuery invokes postCocoonQuery operation. + // + // Proxy arbitrary OpenAI-style JSON to Cocoon (POST). + // + // POST /v2/cocoon/query + PostCocoonQuery(ctx context.Context, request jx.Raw, params PostCocoonQueryParams) (PostCocoonQueryRes, error) + // PostCocoonV1ChatCompletions invokes postCocoonV1ChatCompletions operation. + // + // OpenAI-compatible [Create chat completion](https://developers.openai. + // com/api/reference/resources/chat/subresources/completions/methods/create). + // + // POST /v2/cocoon/v1/chat/completions + PostCocoonV1ChatCompletions(ctx context.Context, request jx.Raw) (PostCocoonV1ChatCompletionsRes, error) // ReindexAccount invokes reindexAccount operation. // // Update internal cache for a particular account. @@ -6605,6 +6624,80 @@ func (c *Client) sendGetChartRates(ctx context.Context, params GetChartRatesPara return result, nil } +// GetCocoonWorkers invokes getCocoonWorkers operation. +// +// Cocoon worker types (same shape as gocoon Connection.GetWorkerTypes). +// +// GET /v2/cocoon/workers +func (c *Client) GetCocoonWorkers(ctx context.Context) (GetCocoonWorkersRes, error) { + res, err := c.sendGetCocoonWorkers(ctx) + return res, err +} + +func (c *Client) sendGetCocoonWorkers(ctx context.Context) (res GetCocoonWorkersRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getCocoonWorkers"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.URLTemplateKey.String("/v2/cocoon/workers"), + } + otelAttrs = append(otelAttrs, c.cfg.Attributes...) + + // 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, GetCocoonWorkersOperation, + 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/cocoon/workers" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeRequest" + r, err := ht.NewRequest(ctx, "GET", u) + if err != nil { + return res, errors.Wrap(err, "create request") + } + + stage = "SendRequest" + resp, err := c.cfg.Client.Do(r) + if err != nil { + return res, errors.Wrap(err, "do request") + } + body := resp.Body + defer body.Close() + + stage = "DecodeResponse" + result, err := decodeGetCocoonWorkersResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // GetDnsInfo invokes getDnsInfo operation. // // Get full information about domain name. @@ -12358,6 +12451,199 @@ func (c *Client) sendGetWalletsByPublicKeyBulk(ctx context.Context, request OptG return result, nil } +// PostCocoonQuery invokes postCocoonQuery operation. +// +// Proxy arbitrary OpenAI-style JSON to Cocoon (POST). +// +// POST /v2/cocoon/query +func (c *Client) PostCocoonQuery(ctx context.Context, request jx.Raw, params PostCocoonQueryParams) (PostCocoonQueryRes, error) { + res, err := c.sendPostCocoonQuery(ctx, request, params) + return res, err +} + +func (c *Client) sendPostCocoonQuery(ctx context.Context, request jx.Raw, params PostCocoonQueryParams) (res PostCocoonQueryRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("postCocoonQuery"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.URLTemplateKey.String("/v2/cocoon/query"), + } + otelAttrs = append(otelAttrs, c.cfg.Attributes...) + + // 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, PostCocoonQueryOperation, + 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/cocoon/query" + uri.AddPathParts(u, pathParts[:]...) + + stage = "EncodeQueryParams" + q := uri.NewQueryEncoder() + { + // Encode "model" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "model", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Model.Get(); ok { + return e.EncodeValue(conv.StringToString(val)) + } + return nil + }); err != nil { + return res, errors.Wrap(err, "encode query") + } + } + { + // Encode "path" parameter. + cfg := uri.QueryParameterEncodingConfig{ + Name: "path", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.EncodeParam(cfg, func(e uri.Encoder) error { + if val, ok := params.Path.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 { + return res, errors.Wrap(err, "create request") + } + if err := encodePostCocoonQueryRequest(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") + } + body := resp.Body + defer body.Close() + + stage = "DecodeResponse" + result, err := decodePostCocoonQueryResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + +// PostCocoonV1ChatCompletions invokes postCocoonV1ChatCompletions operation. +// +// OpenAI-compatible [Create chat completion](https://developers.openai. +// com/api/reference/resources/chat/subresources/completions/methods/create). +// +// POST /v2/cocoon/v1/chat/completions +func (c *Client) PostCocoonV1ChatCompletions(ctx context.Context, request jx.Raw) (PostCocoonV1ChatCompletionsRes, error) { + res, err := c.sendPostCocoonV1ChatCompletions(ctx, request) + return res, err +} + +func (c *Client) sendPostCocoonV1ChatCompletions(ctx context.Context, request jx.Raw) (res PostCocoonV1ChatCompletionsRes, err error) { + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("postCocoonV1ChatCompletions"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.URLTemplateKey.String("/v2/cocoon/v1/chat/completions"), + } + otelAttrs = append(otelAttrs, c.cfg.Attributes...) + + // 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, PostCocoonV1ChatCompletionsOperation, + 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/cocoon/v1/chat/completions" + 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 := encodePostCocoonV1ChatCompletionsRequest(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") + } + body := resp.Body + defer body.Close() + + stage = "DecodeResponse" + result, err := decodePostCocoonV1ChatCompletionsResponse(resp) + if err != nil { + return res, errors.Wrap(err, "decode response") + } + + return result, nil +} + // ReindexAccount invokes reindexAccount operation. // // Update internal cache for a particular account. diff --git a/pkg/oas/oas_handlers_gen.go b/pkg/oas/oas_handlers_gen.go index e80afa6d..38c5b952 100644 --- a/pkg/oas/oas_handlers_gen.go +++ b/pkg/oas/oas_handlers_gen.go @@ -8184,6 +8184,141 @@ func (s *Server) handleGetChartRatesRequest(args [0]string, argsEscaped bool, w } } +// handleGetCocoonWorkersRequest handles getCocoonWorkers operation. +// +// Cocoon worker types (same shape as gocoon Connection.GetWorkerTypes). +// +// GET /v2/cocoon/workers +func (s *Server) handleGetCocoonWorkersRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + statusWriter := &codeRecorder{ResponseWriter: w} + w = statusWriter + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("getCocoonWorkers"), + semconv.HTTPRequestMethodKey.String("GET"), + semconv.HTTPRouteKey.String("/v2/cocoon/workers"), + } + // Add attributes from config. + otelAttrs = append(otelAttrs, s.cfg.Attributes...) + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), GetCocoonWorkersOperation, + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Add Labeler to context. + labeler := &Labeler{attrs: otelAttrs} + ctx = contextWithLabeler(ctx, labeler) + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + + attrSet := labeler.AttributeSet() + attrs := attrSet.ToSlice() + code := statusWriter.status + if code != 0 { + codeAttr := semconv.HTTPResponseStatusCode(code) + attrs = append(attrs, codeAttr) + span.SetAttributes(codeAttr) + } + attrOpt := metric.WithAttributes(attrs...) + + // Increment request counter. + s.requests.Add(ctx, 1, attrOpt) + + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) + }() + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + + // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status + // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, + // unless there was another error (e.g., network error receiving the response body; or 3xx codes with + // max redirects exceeded), in which case status MUST be set to Error. + code := statusWriter.status + if code < 100 || code >= 500 { + span.SetStatus(codes.Error, stage) + } + + attrSet := labeler.AttributeSet() + attrs := attrSet.ToSlice() + if code != 0 { + attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) + } + + s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) + } + err error + ) + + var rawBody []byte + + var response GetCocoonWorkersRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: GetCocoonWorkersOperation, + OperationSummary: "", + OperationID: "getCocoonWorkers", + Body: nil, + RawBody: rawBody, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = struct{} + Params = struct{} + Response = GetCocoonWorkersRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.GetCocoonWorkers(ctx) + return response, err + }, + ) + } else { + response, err = s.h.GetCocoonWorkers(ctx) + } + if err != nil { + if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { + if err := encodeErrorResponse(errRes, w, span); err != nil { + defer recordError("Internal", err) + } + return + } + if errors.Is(err, ht.ErrNotImplemented) { + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { + defer recordError("Internal", err) + } + return + } + + if err := encodeGetCocoonWorkersResponse(response, w, span); err != nil { + defer recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + // handleGetDnsInfoRequest handles getDnsInfo operation. // // Get full information about domain name. @@ -16694,6 +16829,334 @@ func (s *Server) handleGetWalletsByPublicKeyBulkRequest(args [0]string, argsEsca } } +// handlePostCocoonQueryRequest handles postCocoonQuery operation. +// +// Proxy arbitrary OpenAI-style JSON to Cocoon (POST). +// +// POST /v2/cocoon/query +func (s *Server) handlePostCocoonQueryRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + statusWriter := &codeRecorder{ResponseWriter: w} + w = statusWriter + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("postCocoonQuery"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/v2/cocoon/query"), + } + // Add attributes from config. + otelAttrs = append(otelAttrs, s.cfg.Attributes...) + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), PostCocoonQueryOperation, + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Add Labeler to context. + labeler := &Labeler{attrs: otelAttrs} + ctx = contextWithLabeler(ctx, labeler) + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + + attrSet := labeler.AttributeSet() + attrs := attrSet.ToSlice() + code := statusWriter.status + if code != 0 { + codeAttr := semconv.HTTPResponseStatusCode(code) + attrs = append(attrs, codeAttr) + span.SetAttributes(codeAttr) + } + attrOpt := metric.WithAttributes(attrs...) + + // Increment request counter. + s.requests.Add(ctx, 1, attrOpt) + + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) + }() + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + + // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status + // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, + // unless there was another error (e.g., network error receiving the response body; or 3xx codes with + // max redirects exceeded), in which case status MUST be set to Error. + code := statusWriter.status + if code < 100 || code >= 500 { + span.SetStatus(codes.Error, stage) + } + + attrSet := labeler.AttributeSet() + attrs := attrSet.ToSlice() + if code != 0 { + attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) + } + + s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: PostCocoonQueryOperation, + ID: "postCocoonQuery", + } + ) + params, err := decodePostCocoonQueryParams(args, argsEscaped, r) + if err != nil { + err = &ogenerrors.DecodeParamsError{ + OperationContext: opErrContext, + Err: err, + } + defer recordError("DecodeParams", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + + var rawBody []byte + request, rawBody, close, err := s.decodePostCocoonQueryRequest(r) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + defer recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response PostCocoonQueryRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: PostCocoonQueryOperation, + OperationSummary: "", + OperationID: "postCocoonQuery", + Body: request, + RawBody: rawBody, + Params: middleware.Parameters{ + { + Name: "model", + In: "query", + }: params.Model, + { + Name: "path", + In: "query", + }: params.Path, + }, + Raw: r, + } + + type ( + Request = jx.Raw + Params = PostCocoonQueryParams + Response = PostCocoonQueryRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + unpackPostCocoonQueryParams, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.PostCocoonQuery(ctx, request, params) + return response, err + }, + ) + } else { + response, err = s.h.PostCocoonQuery(ctx, request, params) + } + if err != nil { + if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { + if err := encodeErrorResponse(errRes, w, span); err != nil { + defer recordError("Internal", err) + } + return + } + if errors.Is(err, ht.ErrNotImplemented) { + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { + defer recordError("Internal", err) + } + return + } + + if err := encodePostCocoonQueryResponse(response, w, span); err != nil { + defer recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + +// handlePostCocoonV1ChatCompletionsRequest handles postCocoonV1ChatCompletions operation. +// +// OpenAI-compatible [Create chat completion](https://developers.openai. +// com/api/reference/resources/chat/subresources/completions/methods/create). +// +// POST /v2/cocoon/v1/chat/completions +func (s *Server) handlePostCocoonV1ChatCompletionsRequest(args [0]string, argsEscaped bool, w http.ResponseWriter, r *http.Request) { + statusWriter := &codeRecorder{ResponseWriter: w} + w = statusWriter + otelAttrs := []attribute.KeyValue{ + otelogen.OperationID("postCocoonV1ChatCompletions"), + semconv.HTTPRequestMethodKey.String("POST"), + semconv.HTTPRouteKey.String("/v2/cocoon/v1/chat/completions"), + } + // Add attributes from config. + otelAttrs = append(otelAttrs, s.cfg.Attributes...) + + // Start a span for this request. + ctx, span := s.cfg.Tracer.Start(r.Context(), PostCocoonV1ChatCompletionsOperation, + trace.WithAttributes(otelAttrs...), + serverSpanKind, + ) + defer span.End() + + // Add Labeler to context. + labeler := &Labeler{attrs: otelAttrs} + ctx = contextWithLabeler(ctx, labeler) + + // Run stopwatch. + startTime := time.Now() + defer func() { + elapsedDuration := time.Since(startTime) + + attrSet := labeler.AttributeSet() + attrs := attrSet.ToSlice() + code := statusWriter.status + if code != 0 { + codeAttr := semconv.HTTPResponseStatusCode(code) + attrs = append(attrs, codeAttr) + span.SetAttributes(codeAttr) + } + attrOpt := metric.WithAttributes(attrs...) + + // Increment request counter. + s.requests.Add(ctx, 1, attrOpt) + + // Use floating point division here for higher precision (instead of Millisecond method). + s.duration.Record(ctx, float64(elapsedDuration)/float64(time.Millisecond), attrOpt) + }() + + var ( + recordError = func(stage string, err error) { + span.RecordError(err) + + // https://opentelemetry.io/docs/specs/semconv/http/http-spans/#status + // Span Status MUST be left unset if HTTP status code was in the 1xx, 2xx or 3xx ranges, + // unless there was another error (e.g., network error receiving the response body; or 3xx codes with + // max redirects exceeded), in which case status MUST be set to Error. + code := statusWriter.status + if code < 100 || code >= 500 { + span.SetStatus(codes.Error, stage) + } + + attrSet := labeler.AttributeSet() + attrs := attrSet.ToSlice() + if code != 0 { + attrs = append(attrs, semconv.HTTPResponseStatusCode(code)) + } + + s.errors.Add(ctx, 1, metric.WithAttributes(attrs...)) + } + err error + opErrContext = ogenerrors.OperationContext{ + Name: PostCocoonV1ChatCompletionsOperation, + ID: "postCocoonV1ChatCompletions", + } + ) + + var rawBody []byte + request, rawBody, close, err := s.decodePostCocoonV1ChatCompletionsRequest(r) + if err != nil { + err = &ogenerrors.DecodeRequestError{ + OperationContext: opErrContext, + Err: err, + } + defer recordError("DecodeRequest", err) + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + defer func() { + if err := close(); err != nil { + recordError("CloseRequest", err) + } + }() + + var response PostCocoonV1ChatCompletionsRes + if m := s.cfg.Middleware; m != nil { + mreq := middleware.Request{ + Context: ctx, + OperationName: PostCocoonV1ChatCompletionsOperation, + OperationSummary: "", + OperationID: "postCocoonV1ChatCompletions", + Body: request, + RawBody: rawBody, + Params: middleware.Parameters{}, + Raw: r, + } + + type ( + Request = jx.Raw + Params = struct{} + Response = PostCocoonV1ChatCompletionsRes + ) + response, err = middleware.HookMiddleware[ + Request, + Params, + Response, + ]( + m, + mreq, + nil, + func(ctx context.Context, request Request, params Params) (response Response, err error) { + response, err = s.h.PostCocoonV1ChatCompletions(ctx, request) + return response, err + }, + ) + } else { + response, err = s.h.PostCocoonV1ChatCompletions(ctx, request) + } + if err != nil { + if errRes, ok := errors.Into[*ErrorStatusCode](err); ok { + if err := encodeErrorResponse(errRes, w, span); err != nil { + defer recordError("Internal", err) + } + return + } + if errors.Is(err, ht.ErrNotImplemented) { + s.cfg.ErrorHandler(ctx, w, r, err) + return + } + if err := encodeErrorResponse(s.h.NewError(ctx, err), w, span); err != nil { + defer recordError("Internal", err) + } + return + } + + if err := encodePostCocoonV1ChatCompletionsResponse(response, w, span); err != nil { + defer recordError("EncodeResponse", err) + if !errors.Is(err, ht.ErrInternalServerErrorResponse) { + s.cfg.ErrorHandler(ctx, w, r, err) + } + return + } +} + // handleReindexAccountRequest handles reindexAccount operation. // // Update internal cache for a particular account. diff --git a/pkg/oas/oas_interfaces_gen.go b/pkg/oas/oas_interfaces_gen.go new file mode 100644 index 00000000..adb6bb76 --- /dev/null +++ b/pkg/oas/oas_interfaces_gen.go @@ -0,0 +1,14 @@ +// Code generated by ogen, DO NOT EDIT. +package oas + +type GetCocoonWorkersRes interface { + getCocoonWorkersRes() +} + +type PostCocoonQueryRes interface { + postCocoonQueryRes() +} + +type PostCocoonV1ChatCompletionsRes interface { + postCocoonV1ChatCompletionsRes() +} diff --git a/pkg/oas/oas_json_gen.go b/pkg/oas/oas_json_gen.go index 99c0d5e0..2452f9af 100644 --- a/pkg/oas/oas_json_gen.go +++ b/pkg/oas/oas_json_gen.go @@ -11860,175 +11860,90 @@ func (s *ChartPoints) UnmarshalJSON(data []byte) error { } // Encode implements json.Marshaler. -func (s *ComputePhase) Encode(e *jx.Encoder) { +func (s *CocoonWorkerInstance) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ComputePhase) encodeFields(e *jx.Encoder) { - { - e.FieldStart("skipped") - e.Bool(s.Skipped) - } - { - if s.SkipReason.Set { - e.FieldStart("skip_reason") - s.SkipReason.Encode(e) - } - } - { - if s.Success.Set { - e.FieldStart("success") - s.Success.Encode(e) - } - } - { - if s.GasFees.Set { - e.FieldStart("gas_fees") - s.GasFees.Encode(e) - } - } +func (s *CocoonWorkerInstance) encodeFields(e *jx.Encoder) { { - if s.GasUsed.Set { - e.FieldStart("gas_used") - s.GasUsed.Encode(e) - } - } - { - if s.VMSteps.Set { - e.FieldStart("vm_steps") - s.VMSteps.Encode(e) - } + e.FieldStart("coefficient") + e.Int64(s.Coefficient) } { - if s.ExitCode.Set { - e.FieldStart("exit_code") - s.ExitCode.Encode(e) - } + e.FieldStart("active_requests") + e.Int64(s.ActiveRequests) } { - if s.ExitCodeDescription.Set { - e.FieldStart("exit_code_description") - s.ExitCodeDescription.Encode(e) - } + e.FieldStart("max_active_requests") + e.Int64(s.MaxActiveRequests) } } -var jsonFieldsNameOfComputePhase = [8]string{ - 0: "skipped", - 1: "skip_reason", - 2: "success", - 3: "gas_fees", - 4: "gas_used", - 5: "vm_steps", - 6: "exit_code", - 7: "exit_code_description", +var jsonFieldsNameOfCocoonWorkerInstance = [3]string{ + 0: "coefficient", + 1: "active_requests", + 2: "max_active_requests", } -// Decode decodes ComputePhase from json. -func (s *ComputePhase) Decode(d *jx.Decoder) error { +// Decode decodes CocoonWorkerInstance from json. +func (s *CocoonWorkerInstance) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ComputePhase to nil") + return errors.New("invalid: unable to decode CocoonWorkerInstance to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "skipped": + case "coefficient": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Bool() - s.Skipped = bool(v) + v, err := d.Int64() + s.Coefficient = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"skipped\"") - } - case "skip_reason": - if err := func() error { - s.SkipReason.Reset() - if err := s.SkipReason.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"skip_reason\"") - } - case "success": - if err := func() error { - s.Success.Reset() - if err := s.Success.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"success\"") - } - case "gas_fees": - if err := func() error { - s.GasFees.Reset() - if err := s.GasFees.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"gas_fees\"") - } - case "gas_used": - if err := func() error { - s.GasUsed.Reset() - if err := s.GasUsed.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"gas_used\"") - } - case "vm_steps": - if err := func() error { - s.VMSteps.Reset() - if err := s.VMSteps.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"vm_steps\"") + return errors.Wrap(err, "decode field \"coefficient\"") } - case "exit_code": + case "active_requests": + requiredBitSet[0] |= 1 << 1 if err := func() error { - s.ExitCode.Reset() - if err := s.ExitCode.Decode(d); err != nil { + v, err := d.Int64() + s.ActiveRequests = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"exit_code\"") + return errors.Wrap(err, "decode field \"active_requests\"") } - case "exit_code_description": + case "max_active_requests": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.ExitCodeDescription.Reset() - if err := s.ExitCodeDescription.Decode(d); err != nil { + v, err := d.Int64() + s.MaxActiveRequests = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"exit_code_description\"") + return errors.Wrap(err, "decode field \"max_active_requests\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ComputePhase") + return errors.Wrap(err, "decode CocoonWorkerInstance") } // 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. @@ -12040,8 +11955,8 @@ func (s *ComputePhase) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfComputePhase) { - name = jsonFieldsNameOfComputePhase[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfCocoonWorkerInstance) { + name = jsonFieldsNameOfCocoonWorkerInstance[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -12062,232 +11977,96 @@ func (s *ComputePhase) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ComputePhase) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ComputePhase) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes ComputeSkipReason as json. -func (s ComputeSkipReason) Encode(e *jx.Encoder) { - e.Str(string(s)) -} - -// Decode decodes ComputeSkipReason from json. -func (s *ComputeSkipReason) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode ComputeSkipReason to nil") - } - v, err := d.StrBytes() - if err != nil { - return err - } - // Try to use constant string. - switch ComputeSkipReason(v) { - case ComputeSkipReasonCskipNoState: - *s = ComputeSkipReasonCskipNoState - case ComputeSkipReasonCskipBadState: - *s = ComputeSkipReasonCskipBadState - case ComputeSkipReasonCskipNoGas: - *s = ComputeSkipReasonCskipNoGas - case ComputeSkipReasonCskipSuspended: - *s = ComputeSkipReasonCskipSuspended - default: - *s = ComputeSkipReason(v) - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s ComputeSkipReason) MarshalJSON() ([]byte, error) { +func (s *CocoonWorkerInstance) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ComputeSkipReason) UnmarshalJSON(data []byte) error { +func (s *CocoonWorkerInstance) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ConfigProposalSetup) Encode(e *jx.Encoder) { +func (s *CocoonWorkerType) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ConfigProposalSetup) encodeFields(e *jx.Encoder) { - { - e.FieldStart("min_tot_rounds") - e.Int(s.MinTotRounds) - } - { - e.FieldStart("max_tot_rounds") - e.Int(s.MaxTotRounds) - } - { - e.FieldStart("min_wins") - e.Int(s.MinWins) - } - { - e.FieldStart("max_losses") - e.Int(s.MaxLosses) - } +func (s *CocoonWorkerType) encodeFields(e *jx.Encoder) { { - e.FieldStart("min_store_sec") - e.Int64(s.MinStoreSec) - } - { - e.FieldStart("max_store_sec") - e.Int64(s.MaxStoreSec) - } - { - e.FieldStart("bit_price") - e.Int64(s.BitPrice) + e.FieldStart("name") + e.Str(s.Name) } { - e.FieldStart("cell_price") - e.Int64(s.CellPrice) + e.FieldStart("workers") + e.ArrStart() + for _, elem := range s.Workers { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfConfigProposalSetup = [8]string{ - 0: "min_tot_rounds", - 1: "max_tot_rounds", - 2: "min_wins", - 3: "max_losses", - 4: "min_store_sec", - 5: "max_store_sec", - 6: "bit_price", - 7: "cell_price", +var jsonFieldsNameOfCocoonWorkerType = [2]string{ + 0: "name", + 1: "workers", } -// Decode decodes ConfigProposalSetup from json. -func (s *ConfigProposalSetup) Decode(d *jx.Decoder) error { +// Decode decodes CocoonWorkerType from json. +func (s *CocoonWorkerType) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ConfigProposalSetup to nil") + return errors.New("invalid: unable to decode CocoonWorkerType to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "min_tot_rounds": + case "name": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int() - s.MinTotRounds = int(v) + v, err := d.Str() + s.Name = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"min_tot_rounds\"") + return errors.Wrap(err, "decode field \"name\"") } - case "max_tot_rounds": + case "workers": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int() - s.MaxTotRounds = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"max_tot_rounds\"") - } - case "min_wins": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Int() - s.MinWins = int(v) - if err != nil { + s.Workers = make([]CocoonWorkerInstance, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem CocoonWorkerInstance + if err := elem.Decode(d); err != nil { + return err + } + s.Workers = append(s.Workers, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"min_wins\"") - } - case "max_losses": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Int() - s.MaxLosses = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"max_losses\"") - } - case "min_store_sec": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Int64() - s.MinStoreSec = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"min_store_sec\"") - } - case "max_store_sec": - requiredBitSet[0] |= 1 << 5 - if err := func() error { - v, err := d.Int64() - s.MaxStoreSec = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"max_store_sec\"") - } - case "bit_price": - requiredBitSet[0] |= 1 << 6 - if err := func() error { - v, err := d.Int64() - s.BitPrice = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"bit_price\"") - } - case "cell_price": - requiredBitSet[0] |= 1 << 7 - if err := func() error { - v, err := d.Int64() - s.CellPrice = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"cell_price\"") + return errors.Wrap(err, "decode field \"workers\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ConfigProposalSetup") + return errors.Wrap(err, "decode CocoonWorkerType") } // 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. @@ -12299,8 +12078,8 @@ func (s *ConfigProposalSetup) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfConfigProposalSetup) { - name = jsonFieldsNameOfConfigProposalSetup[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfCocoonWorkerType) { + name = jsonFieldsNameOfCocoonWorkerType[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -12321,98 +12100,79 @@ func (s *ConfigProposalSetup) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ConfigProposalSetup) MarshalJSON() ([]byte, error) { +func (s *CocoonWorkerType) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ConfigProposalSetup) UnmarshalJSON(data []byte) error { +func (s *CocoonWorkerType) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ContractDeployAction) Encode(e *jx.Encoder) { +func (s *CocoonWorkersResponse) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ContractDeployAction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } +func (s *CocoonWorkersResponse) encodeFields(e *jx.Encoder) { { - e.FieldStart("interfaces") + e.FieldStart("types") e.ArrStart() - for _, elem := range s.Interfaces { - e.Str(elem) + for _, elem := range s.Types { + elem.Encode(e) } e.ArrEnd() } } -var jsonFieldsNameOfContractDeployAction = [2]string{ - 0: "address", - 1: "interfaces", +var jsonFieldsNameOfCocoonWorkersResponse = [1]string{ + 0: "types", } -// Decode decodes ContractDeployAction from json. -func (s *ContractDeployAction) Decode(d *jx.Decoder) error { +// Decode decodes CocoonWorkersResponse from json. +func (s *CocoonWorkersResponse) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ContractDeployAction to nil") + return errors.New("invalid: unable to decode CocoonWorkersResponse to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "types": 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 "interfaces": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - s.Interfaces = make([]string, 0) + s.Types = make([]CocoonWorkerType, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { + var elem CocoonWorkerType + if err := elem.Decode(d); err != nil { return err } - s.Interfaces = append(s.Interfaces, elem) + s.Types = append(s.Types, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"interfaces\"") + return errors.Wrap(err, "decode field \"types\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ContractDeployAction") + return errors.Wrap(err, "decode CocoonWorkersResponse") } // 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. @@ -12424,8 +12184,8 @@ func (s *ContractDeployAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfContractDeployAction) { - name = jsonFieldsNameOfContractDeployAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfCocoonWorkersResponse) { + name = jsonFieldsNameOfCocoonWorkersResponse[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -12446,86 +12206,188 @@ func (s *ContractDeployAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ContractDeployAction) MarshalJSON() ([]byte, error) { +func (s *CocoonWorkersResponse) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ContractDeployAction) UnmarshalJSON(data []byte) error { +func (s *CocoonWorkersResponse) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *CreditPhase) Encode(e *jx.Encoder) { +func (s *ComputePhase) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *CreditPhase) encodeFields(e *jx.Encoder) { +func (s *ComputePhase) encodeFields(e *jx.Encoder) { { - e.FieldStart("fees_collected") - e.Int64(s.FeesCollected) + e.FieldStart("skipped") + e.Bool(s.Skipped) } { - e.FieldStart("credit") - e.Int64(s.Credit) + if s.SkipReason.Set { + e.FieldStart("skip_reason") + s.SkipReason.Encode(e) + } + } + { + if s.Success.Set { + e.FieldStart("success") + s.Success.Encode(e) + } + } + { + if s.GasFees.Set { + e.FieldStart("gas_fees") + s.GasFees.Encode(e) + } + } + { + if s.GasUsed.Set { + e.FieldStart("gas_used") + s.GasUsed.Encode(e) + } + } + { + if s.VMSteps.Set { + e.FieldStart("vm_steps") + s.VMSteps.Encode(e) + } + } + { + if s.ExitCode.Set { + e.FieldStart("exit_code") + s.ExitCode.Encode(e) + } + } + { + if s.ExitCodeDescription.Set { + e.FieldStart("exit_code_description") + s.ExitCodeDescription.Encode(e) + } } } -var jsonFieldsNameOfCreditPhase = [2]string{ - 0: "fees_collected", - 1: "credit", +var jsonFieldsNameOfComputePhase = [8]string{ + 0: "skipped", + 1: "skip_reason", + 2: "success", + 3: "gas_fees", + 4: "gas_used", + 5: "vm_steps", + 6: "exit_code", + 7: "exit_code_description", } -// Decode decodes CreditPhase from json. -func (s *CreditPhase) Decode(d *jx.Decoder) error { +// Decode decodes ComputePhase from json. +func (s *ComputePhase) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode CreditPhase to nil") + return errors.New("invalid: unable to decode ComputePhase to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "fees_collected": + case "skipped": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.FeesCollected = int64(v) + v, err := d.Bool() + s.Skipped = bool(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"fees_collected\"") + return errors.Wrap(err, "decode field \"skipped\"") } - case "credit": - requiredBitSet[0] |= 1 << 1 + case "skip_reason": if err := func() error { - v, err := d.Int64() - s.Credit = int64(v) - if err != nil { + s.SkipReason.Reset() + if err := s.SkipReason.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"credit\"") + return errors.Wrap(err, "decode field \"skip_reason\"") + } + case "success": + if err := func() error { + s.Success.Reset() + if err := s.Success.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"success\"") + } + case "gas_fees": + if err := func() error { + s.GasFees.Reset() + if err := s.GasFees.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"gas_fees\"") + } + case "gas_used": + if err := func() error { + s.GasUsed.Reset() + if err := s.GasUsed.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"gas_used\"") + } + case "vm_steps": + if err := func() error { + s.VMSteps.Reset() + if err := s.VMSteps.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"vm_steps\"") + } + case "exit_code": + if err := func() error { + s.ExitCode.Reset() + if err := s.ExitCode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"exit_code\"") + } + case "exit_code_description": + if err := func() error { + s.ExitCodeDescription.Reset() + if err := s.ExitCodeDescription.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"exit_code_description\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode CreditPhase") + return errors.Wrap(err, "decode ComputePhase") } // 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. @@ -12537,8 +12399,8 @@ func (s *CreditPhase) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfCreditPhase) { - name = jsonFieldsNameOfCreditPhase[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfComputePhase) { + name = jsonFieldsNameOfComputePhase[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -12559,113 +12421,232 @@ func (s *CreditPhase) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *CreditPhase) MarshalJSON() ([]byte, error) { +func (s *ComputePhase) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *CreditPhase) UnmarshalJSON(data []byte) error { +func (s *ComputePhase) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode encodes CurrencyType as json. -func (s CurrencyType) Encode(e *jx.Encoder) { +// Encode encodes ComputeSkipReason as json. +func (s ComputeSkipReason) Encode(e *jx.Encoder) { e.Str(string(s)) } -// Decode decodes CurrencyType from json. -func (s *CurrencyType) Decode(d *jx.Decoder) error { +// Decode decodes ComputeSkipReason from json. +func (s *ComputeSkipReason) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode CurrencyType to nil") + return errors.New("invalid: unable to decode ComputeSkipReason 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 + switch ComputeSkipReason(v) { + case ComputeSkipReasonCskipNoState: + *s = ComputeSkipReasonCskipNoState + case ComputeSkipReasonCskipBadState: + *s = ComputeSkipReasonCskipBadState + case ComputeSkipReasonCskipNoGas: + *s = ComputeSkipReasonCskipNoGas + case ComputeSkipReasonCskipSuspended: + *s = ComputeSkipReasonCskipSuspended default: - *s = CurrencyType(v) + *s = ComputeSkipReason(v) } return nil } // MarshalJSON implements stdjson.Marshaler. -func (s CurrencyType) MarshalJSON() ([]byte, error) { +func (s ComputeSkipReason) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *CurrencyType) UnmarshalJSON(data []byte) error { +func (s *ComputeSkipReason) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DecodeMessageReq) Encode(e *jx.Encoder) { +func (s *ConfigProposalSetup) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DecodeMessageReq) encodeFields(e *jx.Encoder) { +func (s *ConfigProposalSetup) encodeFields(e *jx.Encoder) { { - e.FieldStart("boc") - e.Str(s.Boc) + e.FieldStart("min_tot_rounds") + e.Int(s.MinTotRounds) + } + { + e.FieldStart("max_tot_rounds") + e.Int(s.MaxTotRounds) + } + { + e.FieldStart("min_wins") + e.Int(s.MinWins) + } + { + e.FieldStart("max_losses") + e.Int(s.MaxLosses) + } + { + e.FieldStart("min_store_sec") + e.Int64(s.MinStoreSec) + } + { + e.FieldStart("max_store_sec") + e.Int64(s.MaxStoreSec) + } + { + e.FieldStart("bit_price") + e.Int64(s.BitPrice) + } + { + e.FieldStart("cell_price") + e.Int64(s.CellPrice) } } -var jsonFieldsNameOfDecodeMessageReq = [1]string{ - 0: "boc", +var jsonFieldsNameOfConfigProposalSetup = [8]string{ + 0: "min_tot_rounds", + 1: "max_tot_rounds", + 2: "min_wins", + 3: "max_losses", + 4: "min_store_sec", + 5: "max_store_sec", + 6: "bit_price", + 7: "cell_price", } -// Decode decodes DecodeMessageReq from json. -func (s *DecodeMessageReq) Decode(d *jx.Decoder) error { +// Decode decodes ConfigProposalSetup from json. +func (s *ConfigProposalSetup) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DecodeMessageReq to nil") + return errors.New("invalid: unable to decode ConfigProposalSetup to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "boc": + case "min_tot_rounds": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Boc = string(v) + v, err := d.Int() + s.MinTotRounds = int(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"boc\"") + return errors.Wrap(err, "decode field \"min_tot_rounds\"") + } + case "max_tot_rounds": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int() + s.MaxTotRounds = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_tot_rounds\"") + } + case "min_wins": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int() + s.MinWins = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"min_wins\"") + } + case "max_losses": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Int() + s.MaxLosses = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_losses\"") + } + case "min_store_sec": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int64() + s.MinStoreSec = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"min_store_sec\"") + } + case "max_store_sec": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Int64() + s.MaxStoreSec = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_store_sec\"") + } + case "bit_price": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + v, err := d.Int64() + s.BitPrice = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bit_price\"") + } + case "cell_price": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + v, err := d.Int64() + s.CellPrice = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cell_price\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DecodeMessageReq") + return errors.Wrap(err, "decode ConfigProposalSetup") } // 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. @@ -12677,8 +12658,8 @@ func (s *DecodeMessageReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDecodeMessageReq) { - name = jsonFieldsNameOfDecodeMessageReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfConfigProposalSetup) { + name = jsonFieldsNameOfConfigProposalSetup[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -12699,96 +12680,93 @@ func (s *DecodeMessageReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DecodeMessageReq) MarshalJSON() ([]byte, error) { +func (s *ConfigProposalSetup) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DecodeMessageReq) UnmarshalJSON(data []byte) error { +func (s *ConfigProposalSetup) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DecodedMessage) Encode(e *jx.Encoder) { +func (s *ContractDeployAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DecodedMessage) encodeFields(e *jx.Encoder) { - { - e.FieldStart("destination") - s.Destination.Encode(e) - } +func (s *ContractDeployAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("destination_wallet_version") - e.Str(s.DestinationWalletVersion) + e.FieldStart("address") + e.Str(s.Address) } { - if s.ExtInMsgDecoded.Set { - e.FieldStart("ext_in_msg_decoded") - s.ExtInMsgDecoded.Encode(e) + e.FieldStart("interfaces") + e.ArrStart() + for _, elem := range s.Interfaces { + e.Str(elem) } + e.ArrEnd() } } -var jsonFieldsNameOfDecodedMessage = [3]string{ - 0: "destination", - 1: "destination_wallet_version", - 2: "ext_in_msg_decoded", +var jsonFieldsNameOfContractDeployAction = [2]string{ + 0: "address", + 1: "interfaces", } -// Decode decodes DecodedMessage from json. -func (s *DecodedMessage) Decode(d *jx.Decoder) error { +// Decode decodes ContractDeployAction from json. +func (s *ContractDeployAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DecodedMessage to nil") + return errors.New("invalid: unable to decode ContractDeployAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "destination": + case "address": requiredBitSet[0] |= 1 << 0 - if err := func() error { - if err := s.Destination.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"destination\"") - } - case "destination_wallet_version": - requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.DestinationWalletVersion = string(v) + s.Address = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"destination_wallet_version\"") + return errors.Wrap(err, "decode field \"address\"") } - case "ext_in_msg_decoded": + case "interfaces": + requiredBitSet[0] |= 1 << 1 if err := func() error { - s.ExtInMsgDecoded.Reset() - if err := s.ExtInMsgDecoded.Decode(d); err != nil { + 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 \"ext_in_msg_decoded\"") + return errors.Wrap(err, "decode field \"interfaces\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DecodedMessage") + return errors.Wrap(err, "decode ContractDeployAction") } // Validate required fields. var failures []validate.FieldError @@ -12805,8 +12783,8 @@ func (s *DecodedMessage) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDecodedMessage) { - name = jsonFieldsNameOfDecodedMessage[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfContractDeployAction) { + name = jsonFieldsNameOfContractDeployAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -12827,227 +12805,86 @@ func (s *DecodedMessage) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DecodedMessage) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DecodedMessage) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s *DecodedMessageExtInMsgDecoded) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *DecodedMessageExtInMsgDecoded) encodeFields(e *jx.Encoder) { - { - if s.WalletV3.Set { - e.FieldStart("wallet_v3") - s.WalletV3.Encode(e) - } - } - { - if s.WalletV4.Set { - e.FieldStart("wallet_v4") - s.WalletV4.Encode(e) - } - } - { - if s.WalletV5.Set { - e.FieldStart("wallet_v5") - s.WalletV5.Encode(e) - } - } - { - if s.WalletHighloadV2.Set { - e.FieldStart("wallet_highload_v2") - s.WalletHighloadV2.Encode(e) - } - } -} - -var jsonFieldsNameOfDecodedMessageExtInMsgDecoded = [4]string{ - 0: "wallet_v3", - 1: "wallet_v4", - 2: "wallet_v5", - 3: "wallet_highload_v2", -} - -// Decode decodes DecodedMessageExtInMsgDecoded from json. -func (s *DecodedMessageExtInMsgDecoded) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecoded to nil") - } - - if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - switch string(k) { - case "wallet_v3": - if err := func() error { - s.WalletV3.Reset() - if err := s.WalletV3.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"wallet_v3\"") - } - case "wallet_v4": - if err := func() error { - s.WalletV4.Reset() - if err := s.WalletV4.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"wallet_v4\"") - } - case "wallet_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() - if err := s.WalletHighloadV2.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"wallet_highload_v2\"") - } - default: - return d.Skip() - } - return nil - }); err != nil { - return errors.Wrap(err, "decode DecodedMessageExtInMsgDecoded") - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s *DecodedMessageExtInMsgDecoded) MarshalJSON() ([]byte, error) { +func (s *ContractDeployAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DecodedMessageExtInMsgDecoded) UnmarshalJSON(data []byte) error { +func (s *ContractDeployAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) Encode(e *jx.Encoder) { +func (s *CreditPhase) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) encodeFields(e *jx.Encoder) { - { - e.FieldStart("subwallet_id") - e.Int64(s.SubwalletID) - } +func (s *CreditPhase) encodeFields(e *jx.Encoder) { { - e.FieldStart("bounded_query_id") - e.Str(s.BoundedQueryID) + e.FieldStart("fees_collected") + e.Int64(s.FeesCollected) } { - e.FieldStart("raw_messages") - e.ArrStart() - for _, elem := range s.RawMessages { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("credit") + e.Int64(s.Credit) } } -var jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletHighloadV2 = [3]string{ - 0: "subwallet_id", - 1: "bounded_query_id", - 2: "raw_messages", +var jsonFieldsNameOfCreditPhase = [2]string{ + 0: "fees_collected", + 1: "credit", } -// Decode decodes DecodedMessageExtInMsgDecodedWalletHighloadV2 from json. -func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) Decode(d *jx.Decoder) error { +// Decode decodes CreditPhase from json. +func (s *CreditPhase) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecodedWalletHighloadV2 to nil") + return errors.New("invalid: unable to decode CreditPhase to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "subwallet_id": + case "fees_collected": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Int64() - s.SubwalletID = int64(v) + s.FeesCollected = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"subwallet_id\"") + return errors.Wrap(err, "decode field \"fees_collected\"") } - case "bounded_query_id": + case "credit": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.BoundedQueryID = string(v) + v, err := d.Int64() + s.Credit = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"bounded_query_id\"") - } - case "raw_messages": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - s.RawMessages = make([]DecodedRawMessage, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem DecodedRawMessage - if err := elem.Decode(d); err != nil { - return err - } - s.RawMessages = append(s.RawMessages, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"raw_messages\"") + return errors.Wrap(err, "decode field \"credit\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DecodedMessageExtInMsgDecodedWalletHighloadV2") + return errors.Wrap(err, "decode CreditPhase") } // 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. @@ -13059,8 +12896,8 @@ func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) Decode(d *jx.Decoder) er bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletHighloadV2) { - name = jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletHighloadV2[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfCreditPhase) { + name = jsonFieldsNameOfCreditPhase[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -13081,130 +12918,113 @@ func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) Decode(d *jx.Decoder) er } // MarshalJSON implements stdjson.Marshaler. -func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) MarshalJSON() ([]byte, error) { +func (s *CreditPhase) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) UnmarshalJSON(data []byte) error { +func (s *CreditPhase) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode implements json.Marshaler. -func (s *DecodedMessageExtInMsgDecodedWalletV3) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() +// Encode encodes CurrencyType as json. +func (s CurrencyType) Encode(e *jx.Encoder) { + e.Str(string(s)) } -// encodeFields encodes fields. -func (s *DecodedMessageExtInMsgDecodedWalletV3) encodeFields(e *jx.Encoder) { - { - e.FieldStart("subwallet_id") - e.Int64(s.SubwalletID) +// 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") } - { - e.FieldStart("valid_until") - e.Int64(s.ValidUntil) + v, err := d.StrBytes() + if err != nil { + return err } - { - e.FieldStart("seqno") - e.Int64(s.Seqno) + // 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) } - { - e.FieldStart("raw_messages") - e.ArrStart() - for _, elem := range s.RawMessages { - elem.Encode(e) - } - e.ArrEnd() + + 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() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DecodeMessageReq) encodeFields(e *jx.Encoder) { + { + e.FieldStart("boc") + e.Str(s.Boc) } } -var jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV3 = [4]string{ - 0: "subwallet_id", - 1: "valid_until", - 2: "seqno", - 3: "raw_messages", +var jsonFieldsNameOfDecodeMessageReq = [1]string{ + 0: "boc", } -// Decode decodes DecodedMessageExtInMsgDecodedWalletV3 from json. -func (s *DecodedMessageExtInMsgDecodedWalletV3) Decode(d *jx.Decoder) error { +// Decode decodes DecodeMessageReq from json. +func (s *DecodeMessageReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecodedWalletV3 to nil") + return errors.New("invalid: unable to decode DecodeMessageReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "subwallet_id": + case "boc": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.SubwalletID = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"subwallet_id\"") - } - case "valid_until": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Int64() - s.ValidUntil = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"valid_until\"") - } - case "seqno": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Int64() - s.Seqno = int64(v) + v, err := d.Str() + s.Boc = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"seqno\"") - } - case "raw_messages": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - s.RawMessages = make([]DecodedRawMessage, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem DecodedRawMessage - if err := elem.Decode(d); err != nil { - return err - } - s.RawMessages = append(s.RawMessages, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"raw_messages\"") + return errors.Wrap(err, "decode field \"boc\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DecodedMessageExtInMsgDecodedWalletV3") + return errors.Wrap(err, "decode DecodeMessageReq") } // 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. @@ -13216,8 +13036,8 @@ func (s *DecodedMessageExtInMsgDecodedWalletV3) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV3) { - name = jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV3[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDecodeMessageReq) { + name = jsonFieldsNameOfDecodeMessageReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -13238,147 +13058,101 @@ func (s *DecodedMessageExtInMsgDecodedWalletV3) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DecodedMessageExtInMsgDecodedWalletV3) MarshalJSON() ([]byte, error) { +func (s *DecodeMessageReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DecodedMessageExtInMsgDecodedWalletV3) UnmarshalJSON(data []byte) error { +func (s *DecodeMessageReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DecodedMessageExtInMsgDecodedWalletV4) Encode(e *jx.Encoder) { +func (s *DecodedMessage) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DecodedMessageExtInMsgDecodedWalletV4) encodeFields(e *jx.Encoder) { - { - e.FieldStart("subwallet_id") - e.Int64(s.SubwalletID) - } - { - e.FieldStart("valid_until") - e.Int64(s.ValidUntil) - } +func (s *DecodedMessage) encodeFields(e *jx.Encoder) { { - e.FieldStart("seqno") - e.Int64(s.Seqno) + e.FieldStart("destination") + s.Destination.Encode(e) } { - e.FieldStart("op") - e.Int32(s.Op) + e.FieldStart("destination_wallet_version") + e.Str(s.DestinationWalletVersion) } { - e.FieldStart("raw_messages") - e.ArrStart() - for _, elem := range s.RawMessages { - elem.Encode(e) + if s.ExtInMsgDecoded.Set { + e.FieldStart("ext_in_msg_decoded") + s.ExtInMsgDecoded.Encode(e) } - e.ArrEnd() } } -var jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV4 = [5]string{ - 0: "subwallet_id", - 1: "valid_until", - 2: "seqno", - 3: "op", - 4: "raw_messages", +var jsonFieldsNameOfDecodedMessage = [3]string{ + 0: "destination", + 1: "destination_wallet_version", + 2: "ext_in_msg_decoded", } -// Decode decodes DecodedMessageExtInMsgDecodedWalletV4 from json. -func (s *DecodedMessageExtInMsgDecodedWalletV4) Decode(d *jx.Decoder) error { +// Decode decodes DecodedMessage from json. +func (s *DecodedMessage) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecodedWalletV4 to nil") + return errors.New("invalid: unable to decode DecodedMessage to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "subwallet_id": + case "destination": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.SubwalletID = int64(v) - if err != nil { + if err := s.Destination.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"subwallet_id\"") + return errors.Wrap(err, "decode field \"destination\"") } - case "valid_until": + case "destination_wallet_version": requiredBitSet[0] |= 1 << 1 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 "seqno": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Int64() - s.Seqno = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"seqno\"") - } - case "op": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Int32() - s.Op = int32(v) + v, err := d.Str() + s.DestinationWalletVersion = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"op\"") + return errors.Wrap(err, "decode field \"destination_wallet_version\"") } - case "raw_messages": - requiredBitSet[0] |= 1 << 4 + case "ext_in_msg_decoded": 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 { + s.ExtInMsgDecoded.Reset() + if err := s.ExtInMsgDecoded.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"raw_messages\"") + return errors.Wrap(err, "decode field \"ext_in_msg_decoded\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DecodedMessageExtInMsgDecodedWalletV4") + return errors.Wrap(err, "decode DecodedMessage") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00011111, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -13390,8 +13164,8 @@ func (s *DecodedMessageExtInMsgDecodedWalletV4) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV4) { - name = jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV4[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDecodedMessage) { + name = jsonFieldsNameOfDecodedMessage[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -13412,69 +13186,200 @@ func (s *DecodedMessageExtInMsgDecodedWalletV4) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DecodedMessageExtInMsgDecodedWalletV4) MarshalJSON() ([]byte, error) { +func (s *DecodedMessage) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DecodedMessageExtInMsgDecodedWalletV4) UnmarshalJSON(data []byte) error { +func (s *DecodedMessage) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DecodedMessageExtInMsgDecodedWalletV5) Encode(e *jx.Encoder) { +func (s *DecodedMessageExtInMsgDecoded) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DecodedMessageExtInMsgDecodedWalletV5) encodeFields(e *jx.Encoder) { +func (s *DecodedMessageExtInMsgDecoded) encodeFields(e *jx.Encoder) { { - e.FieldStart("valid_until") - e.Int64(s.ValidUntil) + if s.WalletV3.Set { + e.FieldStart("wallet_v3") + s.WalletV3.Encode(e) + } } { - e.FieldStart("raw_messages") - e.ArrStart() - for _, elem := range s.RawMessages { - elem.Encode(e) + if s.WalletV4.Set { + e.FieldStart("wallet_v4") + 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") + s.WalletHighloadV2.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 { +var jsonFieldsNameOfDecodedMessageExtInMsgDecoded = [4]string{ + 0: "wallet_v3", + 1: "wallet_v4", + 2: "wallet_v5", + 3: "wallet_highload_v2", +} + +// Decode decodes DecodedMessageExtInMsgDecoded from json. +func (s *DecodedMessageExtInMsgDecoded) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecodedWalletV5 to nil") + return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecoded to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "wallet_v3": + if err := func() error { + s.WalletV3.Reset() + if err := s.WalletV3.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet_v3\"") + } + case "wallet_v4": + if err := func() error { + s.WalletV4.Reset() + if err := s.WalletV4.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet_v4\"") + } + case "wallet_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() + if err := s.WalletHighloadV2.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet_highload_v2\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode DecodedMessageExtInMsgDecoded") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *DecodedMessageExtInMsgDecoded) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *DecodedMessageExtInMsgDecoded) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) encodeFields(e *jx.Encoder) { + { + e.FieldStart("subwallet_id") + e.Int64(s.SubwalletID) + } + { + e.FieldStart("bounded_query_id") + e.Str(s.BoundedQueryID) + } + { + e.FieldStart("raw_messages") + e.ArrStart() + for _, elem := range s.RawMessages { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletHighloadV2 = [3]string{ + 0: "subwallet_id", + 1: "bounded_query_id", + 2: "raw_messages", +} + +// Decode decodes DecodedMessageExtInMsgDecodedWalletHighloadV2 from json. +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecodedWalletHighloadV2 to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "valid_until": + case "subwallet_id": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Int64() - s.ValidUntil = int64(v) + s.SubwalletID = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"valid_until\"") + return errors.Wrap(err, "decode field \"subwallet_id\"") } - case "raw_messages": + case "bounded_query_id": requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.BoundedQueryID = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bounded_query_id\"") + } + case "raw_messages": + requiredBitSet[0] |= 1 << 2 if err := func() error { s.RawMessages = make([]DecodedRawMessage, 0) if err := d.Arr(func(d *jx.Decoder) error { @@ -13496,12 +13401,12 @@ func (s *DecodedMessageExtInMsgDecodedWalletV5) Decode(d *jx.Decoder) error { } return nil }); err != nil { - return errors.Wrap(err, "decode DecodedMessageExtInMsgDecodedWalletV5") + return errors.Wrap(err, "decode DecodedMessageExtInMsgDecodedWalletHighloadV2") } // 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. @@ -13513,8 +13418,8 @@ func (s *DecodedMessageExtInMsgDecodedWalletV5) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV5) { - name = jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV5[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletHighloadV2) { + name = jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletHighloadV2[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -13535,84 +13440,130 @@ func (s *DecodedMessageExtInMsgDecodedWalletV5) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DecodedMessageExtInMsgDecodedWalletV5) MarshalJSON() ([]byte, error) { +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DecodedMessageExtInMsgDecodedWalletV5) UnmarshalJSON(data []byte) error { +func (s *DecodedMessageExtInMsgDecodedWalletHighloadV2) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DecodedRawMessage) Encode(e *jx.Encoder) { +func (s *DecodedMessageExtInMsgDecodedWalletV3) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DecodedRawMessage) encodeFields(e *jx.Encoder) { +func (s *DecodedMessageExtInMsgDecodedWalletV3) encodeFields(e *jx.Encoder) { { - e.FieldStart("message") - s.Message.Encode(e) + e.FieldStart("subwallet_id") + e.Int64(s.SubwalletID) } { - e.FieldStart("mode") - e.Int(s.Mode) + e.FieldStart("valid_until") + e.Int64(s.ValidUntil) + } + { + e.FieldStart("seqno") + e.Int64(s.Seqno) + } + { + e.FieldStart("raw_messages") + e.ArrStart() + for _, elem := range s.RawMessages { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfDecodedRawMessage = [2]string{ - 0: "message", - 1: "mode", +var jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV3 = [4]string{ + 0: "subwallet_id", + 1: "valid_until", + 2: "seqno", + 3: "raw_messages", } -// Decode decodes DecodedRawMessage from json. -func (s *DecodedRawMessage) Decode(d *jx.Decoder) error { +// Decode decodes DecodedMessageExtInMsgDecodedWalletV3 from json. +func (s *DecodedMessageExtInMsgDecodedWalletV3) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DecodedRawMessage to nil") + return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecodedWalletV3 to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "message": + case "subwallet_id": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Message.Decode(d); err != nil { + v, err := d.Int64() + s.SubwalletID = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"message\"") + return errors.Wrap(err, "decode field \"subwallet_id\"") } - case "mode": + case "valid_until": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int() - s.Mode = int(v) + v, err := d.Int64() + s.ValidUntil = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"mode\"") + return errors.Wrap(err, "decode field \"valid_until\"") + } + case "seqno": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int64() + s.Seqno = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"seqno\"") + } + case "raw_messages": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + s.RawMessages = make([]DecodedRawMessage, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem DecodedRawMessage + if err := elem.Decode(d); err != nil { + return err + } + s.RawMessages = append(s.RawMessages, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raw_messages\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DecodedRawMessage") + return errors.Wrap(err, "decode DecodedMessageExtInMsgDecodedWalletV3") } // 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. @@ -13624,8 +13575,8 @@ func (s *DecodedRawMessage) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDecodedRawMessage) { - name = jsonFieldsNameOfDecodedRawMessage[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV3) { + name = jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV3[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -13646,121 +13597,147 @@ func (s *DecodedRawMessage) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DecodedRawMessage) MarshalJSON() ([]byte, error) { +func (s *DecodedMessageExtInMsgDecodedWalletV3) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DecodedRawMessage) UnmarshalJSON(data []byte) error { +func (s *DecodedMessageExtInMsgDecodedWalletV3) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DecodedRawMessageMessage) Encode(e *jx.Encoder) { +func (s *DecodedMessageExtInMsgDecodedWalletV4) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DecodedRawMessageMessage) encodeFields(e *jx.Encoder) { +func (s *DecodedMessageExtInMsgDecodedWalletV4) encodeFields(e *jx.Encoder) { { - e.FieldStart("boc") - e.Str(s.Boc) + e.FieldStart("subwallet_id") + e.Int64(s.SubwalletID) } { - if s.DecodedOpName.Set { - e.FieldStart("decoded_op_name") - s.DecodedOpName.Encode(e) - } + e.FieldStart("valid_until") + e.Int64(s.ValidUntil) } { - if s.OpCode.Set { - e.FieldStart("op_code") - s.OpCode.Encode(e) - } + e.FieldStart("seqno") + e.Int64(s.Seqno) } { - if len(s.DecodedBody) != 0 { - e.FieldStart("decoded_body") - e.Raw(s.DecodedBody) + e.FieldStart("op") + e.Int32(s.Op) + } + { + e.FieldStart("raw_messages") + e.ArrStart() + for _, elem := range s.RawMessages { + elem.Encode(e) } + e.ArrEnd() } } -var jsonFieldsNameOfDecodedRawMessageMessage = [4]string{ - 0: "boc", - 1: "decoded_op_name", - 2: "op_code", - 3: "decoded_body", +var jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV4 = [5]string{ + 0: "subwallet_id", + 1: "valid_until", + 2: "seqno", + 3: "op", + 4: "raw_messages", } -// Decode decodes DecodedRawMessageMessage from json. -func (s *DecodedRawMessageMessage) Decode(d *jx.Decoder) error { +// Decode decodes DecodedMessageExtInMsgDecodedWalletV4 from json. +func (s *DecodedMessageExtInMsgDecodedWalletV4) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DecodedRawMessageMessage to nil") + return errors.New("invalid: unable to decode DecodedMessageExtInMsgDecodedWalletV4 to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "boc": + case "subwallet_id": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Boc = string(v) + v, err := d.Int64() + s.SubwalletID = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"boc\"") + return errors.Wrap(err, "decode field \"subwallet_id\"") } - case "decoded_op_name": + case "valid_until": + requiredBitSet[0] |= 1 << 1 if err := func() error { - s.DecodedOpName.Reset() - if err := s.DecodedOpName.Decode(d); err != nil { + v, err := d.Int64() + s.ValidUntil = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"decoded_op_name\"") + return errors.Wrap(err, "decode field \"valid_until\"") } - case "op_code": + case "seqno": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.OpCode.Reset() - if err := s.OpCode.Decode(d); err != nil { + v, err := d.Int64() + s.Seqno = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"op_code\"") + return errors.Wrap(err, "decode field \"seqno\"") } - case "decoded_body": + case "op": + requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.RawAppend(nil) - s.DecodedBody = jx.Raw(v) + v, err := d.Int32() + s.Op = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"decoded_body\"") + return errors.Wrap(err, "decode field \"op\"") + } + case "raw_messages": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + s.RawMessages = make([]DecodedRawMessage, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem DecodedRawMessage + if err := elem.Decode(d); err != nil { + return err + } + s.RawMessages = append(s.RawMessages, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raw_messages\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DecodedRawMessageMessage") + return errors.Wrap(err, "decode DecodedMessageExtInMsgDecodedWalletV4") } // 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. @@ -13772,8 +13749,8 @@ func (s *DecodedRawMessageMessage) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDecodedRawMessageMessage) { - name = jsonFieldsNameOfDecodedRawMessageMessage[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV4) { + name = jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV4[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -13794,114 +13771,96 @@ func (s *DecodedRawMessageMessage) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DecodedRawMessageMessage) MarshalJSON() ([]byte, error) { +func (s *DecodedMessageExtInMsgDecodedWalletV4) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DecodedRawMessageMessage) UnmarshalJSON(data []byte) error { +func (s *DecodedMessageExtInMsgDecodedWalletV4) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DepositStakeAction) Encode(e *jx.Encoder) { +func (s *DecodedMessageExtInMsgDecodedWalletV5) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DepositStakeAction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("amount") - e.Int64(s.Amount) - } - { - e.FieldStart("staker") - s.Staker.Encode(e) - } +func (s *DecodedMessageExtInMsgDecodedWalletV5) encodeFields(e *jx.Encoder) { { - e.FieldStart("pool") - s.Pool.Encode(e) + e.FieldStart("valid_until") + e.Int64(s.ValidUntil) } { - e.FieldStart("implementation") - s.Implementation.Encode(e) + e.FieldStart("raw_messages") + e.ArrStart() + for _, elem := range s.RawMessages { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfDepositStakeAction = [4]string{ - 0: "amount", - 1: "staker", - 2: "pool", - 3: "implementation", +var jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV5 = [2]string{ + 0: "valid_until", + 1: "raw_messages", } -// Decode decodes DepositStakeAction from json. -func (s *DepositStakeAction) Decode(d *jx.Decoder) error { +// Decode decodes DecodedMessageExtInMsgDecodedWalletV5 from json. +func (s *DecodedMessageExtInMsgDecodedWalletV5) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DepositStakeAction to 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 "amount": + case "valid_until": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Int64() - s.Amount = int64(v) + s.ValidUntil = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") + return errors.Wrap(err, "decode field \"valid_until\"") } - case "staker": + case "raw_messages": 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\"") - } - case "pool": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - if err := s.Pool.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"pool\"") - } - case "implementation": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - if err := s.Implementation.Decode(d); err != nil { + 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 \"implementation\"") + return errors.Wrap(err, "decode field \"raw_messages\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DepositStakeAction") + return errors.Wrap(err, "decode DecodedMessageExtInMsgDecodedWalletV5") } // 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. @@ -13913,8 +13872,8 @@ func (s *DepositStakeAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDepositStakeAction) { - name = jsonFieldsNameOfDepositStakeAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV5) { + name = jsonFieldsNameOfDecodedMessageExtInMsgDecodedWalletV5[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -13935,94 +13894,79 @@ func (s *DepositStakeAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DepositStakeAction) MarshalJSON() ([]byte, error) { +func (s *DecodedMessageExtInMsgDecodedWalletV5) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DepositStakeAction) UnmarshalJSON(data []byte) error { +func (s *DecodedMessageExtInMsgDecodedWalletV5) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DepositTokenStakeAction) Encode(e *jx.Encoder) { +func (s *DecodedRawMessage) 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) - } +func (s *DecodedRawMessage) encodeFields(e *jx.Encoder) { { - e.FieldStart("protocol") - s.Protocol.Encode(e) + e.FieldStart("message") + s.Message.Encode(e) } { - if s.StakeMeta.Set { - e.FieldStart("stake_meta") - s.StakeMeta.Encode(e) - } + e.FieldStart("mode") + e.Int(s.Mode) } } -var jsonFieldsNameOfDepositTokenStakeAction = [3]string{ - 0: "staker", - 1: "protocol", - 2: "stake_meta", +var jsonFieldsNameOfDecodedRawMessage = [2]string{ + 0: "message", + 1: "mode", } -// Decode decodes DepositTokenStakeAction from json. -func (s *DepositTokenStakeAction) Decode(d *jx.Decoder) error { +// Decode decodes DecodedRawMessage from json. +func (s *DecodedRawMessage) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DepositTokenStakeAction to nil") + return errors.New("invalid: unable to decode DecodedRawMessage to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "staker": + case "message": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Staker.Decode(d); err != nil { + if err := s.Message.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"staker\"") + return errors.Wrap(err, "decode field \"message\"") } - case "protocol": + case "mode": 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 { + v, err := d.Int() + s.Mode = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"stake_meta\"") + return errors.Wrap(err, "decode field \"mode\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DepositTokenStakeAction") + return errors.Wrap(err, "decode DecodedRawMessage") } // Validate required fields. var failures []validate.FieldError @@ -14039,8 +13983,8 @@ func (s *DepositTokenStakeAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDepositTokenStakeAction) { - name = jsonFieldsNameOfDepositTokenStakeAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDecodedRawMessage) { + name = jsonFieldsNameOfDecodedRawMessage[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -14061,74 +14005,116 @@ func (s *DepositTokenStakeAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DepositTokenStakeAction) MarshalJSON() ([]byte, error) { +func (s *DecodedRawMessage) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DepositTokenStakeAction) UnmarshalJSON(data []byte) error { +func (s *DecodedRawMessage) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DnsExpiring) Encode(e *jx.Encoder) { +func (s *DecodedRawMessageMessage) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DnsExpiring) encodeFields(e *jx.Encoder) { +func (s *DecodedRawMessageMessage) encodeFields(e *jx.Encoder) { { - e.FieldStart("items") - e.ArrStart() - for _, elem := range s.Items { - elem.Encode(e) + e.FieldStart("boc") + e.Str(s.Boc) + } + { + if s.DecodedOpName.Set { + e.FieldStart("decoded_op_name") + s.DecodedOpName.Encode(e) + } + } + { + if s.OpCode.Set { + e.FieldStart("op_code") + s.OpCode.Encode(e) + } + } + { + if len(s.DecodedBody) != 0 { + e.FieldStart("decoded_body") + e.Raw(s.DecodedBody) } - e.ArrEnd() } } -var jsonFieldsNameOfDnsExpiring = [1]string{ - 0: "items", +var jsonFieldsNameOfDecodedRawMessageMessage = [4]string{ + 0: "boc", + 1: "decoded_op_name", + 2: "op_code", + 3: "decoded_body", } -// Decode decodes DnsExpiring from json. -func (s *DnsExpiring) Decode(d *jx.Decoder) error { +// Decode decodes DecodedRawMessageMessage from json. +func (s *DecodedRawMessageMessage) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DnsExpiring to nil") + return errors.New("invalid: unable to decode DecodedRawMessageMessage to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "items": + case "boc": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Items = make([]DnsExpiringItemsItem, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem DnsExpiringItemsItem - if err := elem.Decode(d); err != nil { - return err - } - s.Items = append(s.Items, elem) - return nil - }); err != nil { + v, err := d.Str() + s.Boc = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"items\"") + return errors.Wrap(err, "decode field \"boc\"") + } + case "decoded_op_name": + if err := func() error { + s.DecodedOpName.Reset() + if err := s.DecodedOpName.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"decoded_op_name\"") + } + case "op_code": + if err := func() error { + s.OpCode.Reset() + if err := s.OpCode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"op_code\"") + } + case "decoded_body": + if err := func() error { + v, err := d.RawAppend(nil) + s.DecodedBody = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"decoded_body\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DnsExpiring") + return errors.Wrap(err, "decode DecodedRawMessageMessage") } // Validate required fields. var failures []validate.FieldError @@ -14145,8 +14131,8 @@ func (s *DnsExpiring) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDnsExpiring) { - name = jsonFieldsNameOfDnsExpiring[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDecodedRawMessageMessage) { + name = jsonFieldsNameOfDecodedRawMessageMessage[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -14167,103 +14153,114 @@ func (s *DnsExpiring) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DnsExpiring) MarshalJSON() ([]byte, error) { +func (s *DecodedRawMessageMessage) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DnsExpiring) UnmarshalJSON(data []byte) error { +func (s *DecodedRawMessageMessage) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DnsExpiringItemsItem) Encode(e *jx.Encoder) { +func (s *DepositStakeAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DnsExpiringItemsItem) encodeFields(e *jx.Encoder) { +func (s *DepositStakeAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("expiring_at") - e.Int64(s.ExpiringAt) + e.FieldStart("amount") + e.Int64(s.Amount) } { - e.FieldStart("name") - e.Str(s.Name) + e.FieldStart("staker") + s.Staker.Encode(e) } { - if s.DNSItem.Set { - e.FieldStart("dns_item") - s.DNSItem.Encode(e) - } + e.FieldStart("pool") + s.Pool.Encode(e) + } + { + e.FieldStart("implementation") + s.Implementation.Encode(e) } } -var jsonFieldsNameOfDnsExpiringItemsItem = [3]string{ - 0: "expiring_at", - 1: "name", - 2: "dns_item", +var jsonFieldsNameOfDepositStakeAction = [4]string{ + 0: "amount", + 1: "staker", + 2: "pool", + 3: "implementation", } -// Decode decodes DnsExpiringItemsItem from json. -func (s *DnsExpiringItemsItem) Decode(d *jx.Decoder) error { +// Decode decodes DepositStakeAction from json. +func (s *DepositStakeAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DnsExpiringItemsItem to nil") + return errors.New("invalid: unable to decode DepositStakeAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "expiring_at": + case "amount": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Int64() - s.ExpiringAt = int64(v) + s.Amount = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"expiring_at\"") + return errors.Wrap(err, "decode field \"amount\"") } - case "name": + case "staker": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.Name = string(v) - if err != nil { + if err := s.Staker.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"name\"") + return errors.Wrap(err, "decode field \"staker\"") } - case "dns_item": + case "pool": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.DNSItem.Reset() - if err := s.DNSItem.Decode(d); err != nil { + if err := s.Pool.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"dns_item\"") + return errors.Wrap(err, "decode field \"pool\"") + } + case "implementation": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + if err := s.Implementation.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"implementation\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DnsExpiringItemsItem") + return errors.Wrap(err, "decode DepositStakeAction") } // 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. @@ -14275,8 +14272,8 @@ func (s *DnsExpiringItemsItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDnsExpiringItemsItem) { - name = jsonFieldsNameOfDnsExpiringItemsItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDepositStakeAction) { + name = jsonFieldsNameOfDepositStakeAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -14297,149 +14294,99 @@ func (s *DnsExpiringItemsItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DnsExpiringItemsItem) MarshalJSON() ([]byte, error) { +func (s *DepositStakeAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DnsExpiringItemsItem) UnmarshalJSON(data []byte) error { +func (s *DepositStakeAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DnsRecord) Encode(e *jx.Encoder) { +func (s *DepositTokenStakeAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DnsRecord) encodeFields(e *jx.Encoder) { - { - if s.Wallet.Set { - e.FieldStart("wallet") - s.Wallet.Encode(e) - } - } - { - if s.NextResolver.Set { - e.FieldStart("next_resolver") - s.NextResolver.Encode(e) - } - } +func (s *DepositTokenStakeAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("sites") - e.ArrStart() - for _, elem := range s.Sites { - e.Str(elem) - } - e.ArrEnd() + e.FieldStart("staker") + s.Staker.Encode(e) } { - if s.Storage.Set { - e.FieldStart("storage") - s.Storage.Encode(e) - } + e.FieldStart("protocol") + s.Protocol.Encode(e) } { - if s.Picture.Set { - e.FieldStart("picture") - s.Picture.Encode(e) + if s.StakeMeta.Set { + e.FieldStart("stake_meta") + s.StakeMeta.Encode(e) } } } -var jsonFieldsNameOfDnsRecord = [5]string{ - 0: "wallet", - 1: "next_resolver", - 2: "sites", - 3: "storage", - 4: "picture", +var jsonFieldsNameOfDepositTokenStakeAction = [3]string{ + 0: "staker", + 1: "protocol", + 2: "stake_meta", } -// Decode decodes DnsRecord from json. -func (s *DnsRecord) Decode(d *jx.Decoder) error { +// Decode decodes DepositTokenStakeAction from json. +func (s *DepositTokenStakeAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DnsRecord to 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 "wallet": + case "staker": + requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Wallet.Reset() - if err := s.Wallet.Decode(d); err != nil { + if err := s.Staker.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"wallet\"") + return errors.Wrap(err, "decode field \"staker\"") } - case "next_resolver": + case "protocol": + requiredBitSet[0] |= 1 << 1 if err := func() error { - s.NextResolver.Reset() - if err := s.NextResolver.Decode(d); err != nil { + if err := s.Protocol.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"next_resolver\"") + return errors.Wrap(err, "decode field \"protocol\"") } - case "sites": - requiredBitSet[0] |= 1 << 2 + case "stake_meta": if err := func() error { - s.Sites = 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.Sites = append(s.Sites, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"sites\"") - } - case "storage": - if err := func() error { - s.Storage.Reset() - if err := s.Storage.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"storage\"") - } - case "picture": - if err := func() error { - s.Picture.Reset() - if err := s.Picture.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 \"picture\"") + return errors.Wrap(err, "decode field \"stake_meta\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DnsRecord") + return errors.Wrap(err, "decode DepositTokenStakeAction") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000100, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -14451,8 +14398,8 @@ func (s *DnsRecord) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDnsRecord) { - name = jsonFieldsNameOfDnsRecord[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDepositTokenStakeAction) { + name = jsonFieldsNameOfDepositTokenStakeAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -14473,136 +14420,79 @@ func (s *DnsRecord) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DnsRecord) MarshalJSON() ([]byte, error) { +func (s *DepositTokenStakeAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DnsRecord) UnmarshalJSON(data []byte) error { +func (s *DepositTokenStakeAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DomainBid) Encode(e *jx.Encoder) { +func (s *DnsExpiring) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DomainBid) encodeFields(e *jx.Encoder) { - { - e.FieldStart("success") - e.Bool(s.Success) - } - { - e.FieldStart("value") - e.Int64(s.Value) - } - { - e.FieldStart("txTime") - e.Int64(s.TxTime) - } - { - e.FieldStart("txHash") - e.Str(s.TxHash) - } +func (s *DnsExpiring) encodeFields(e *jx.Encoder) { { - e.FieldStart("bidder") - s.Bidder.Encode(e) + e.FieldStart("items") + e.ArrStart() + for _, elem := range s.Items { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfDomainBid = [5]string{ - 0: "success", - 1: "value", - 2: "txTime", - 3: "txHash", - 4: "bidder", +var jsonFieldsNameOfDnsExpiring = [1]string{ + 0: "items", } -// Decode decodes DomainBid from json. -func (s *DomainBid) Decode(d *jx.Decoder) error { +// Decode decodes DnsExpiring from json. +func (s *DnsExpiring) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DomainBid to nil") + return errors.New("invalid: unable to decode DnsExpiring to nil") } var requiredBitSet [1]uint8 - s.setDefaults() if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "success": + case "items": requiredBitSet[0] |= 1 << 0 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 "value": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Int64() - s.Value = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"value\"") - } - case "txTime": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Int64() - s.TxTime = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"txTime\"") - } - case "txHash": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Str() - s.TxHash = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"txHash\"") - } - case "bidder": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - if err := s.Bidder.Decode(d); err != nil { + s.Items = make([]DnsExpiringItemsItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem DnsExpiringItemsItem + if err := elem.Decode(d); err != nil { + return err + } + s.Items = append(s.Items, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"bidder\"") + return errors.Wrap(err, "decode field \"items\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DomainBid") + return errors.Wrap(err, "decode DnsExpiring") } // 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. @@ -14614,8 +14504,8 @@ func (s *DomainBid) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDomainBid) { - name = jsonFieldsNameOfDomainBid[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDnsExpiring) { + name = jsonFieldsNameOfDnsExpiring[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -14636,79 +14526,103 @@ func (s *DomainBid) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DomainBid) MarshalJSON() ([]byte, error) { +func (s *DnsExpiring) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DomainBid) UnmarshalJSON(data []byte) error { +func (s *DnsExpiring) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DomainBids) Encode(e *jx.Encoder) { +func (s *DnsExpiringItemsItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DomainBids) encodeFields(e *jx.Encoder) { +func (s *DnsExpiringItemsItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("data") - e.ArrStart() - for _, elem := range s.Data { - elem.Encode(e) + e.FieldStart("expiring_at") + e.Int64(s.ExpiringAt) + } + { + e.FieldStart("name") + e.Str(s.Name) + } + { + if s.DNSItem.Set { + e.FieldStart("dns_item") + s.DNSItem.Encode(e) } - e.ArrEnd() } } -var jsonFieldsNameOfDomainBids = [1]string{ - 0: "data", +var jsonFieldsNameOfDnsExpiringItemsItem = [3]string{ + 0: "expiring_at", + 1: "name", + 2: "dns_item", } -// Decode decodes DomainBids from json. -func (s *DomainBids) Decode(d *jx.Decoder) error { +// Decode decodes DnsExpiringItemsItem from json. +func (s *DnsExpiringItemsItem) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DomainBids to nil") + return errors.New("invalid: unable to decode DnsExpiringItemsItem to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "data": + case "expiring_at": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Data = make([]DomainBid, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem DomainBid - if err := elem.Decode(d); err != nil { - return err - } - s.Data = append(s.Data, elem) - return nil - }); err != nil { + v, err := d.Int64() + s.ExpiringAt = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"data\"") + return errors.Wrap(err, "decode field \"expiring_at\"") + } + 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 "dns_item": + if err := func() error { + s.DNSItem.Reset() + if err := s.DNSItem.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"dns_item\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DomainBids") + return errors.Wrap(err, "decode DnsExpiringItemsItem") } // 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. @@ -14720,8 +14634,8 @@ func (s *DomainBids) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDomainBids) { - name = jsonFieldsNameOfDomainBids[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDnsExpiringItemsItem) { + name = jsonFieldsNameOfDnsExpiringItemsItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -14742,103 +14656,149 @@ func (s *DomainBids) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DomainBids) MarshalJSON() ([]byte, error) { +func (s *DnsExpiringItemsItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DomainBids) UnmarshalJSON(data []byte) error { +func (s *DnsExpiringItemsItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DomainInfo) Encode(e *jx.Encoder) { +func (s *DnsRecord) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DomainInfo) encodeFields(e *jx.Encoder) { +func (s *DnsRecord) encodeFields(e *jx.Encoder) { { - e.FieldStart("name") - e.Str(s.Name) + if s.Wallet.Set { + e.FieldStart("wallet") + s.Wallet.Encode(e) + } } { - if s.ExpiringAt.Set { - e.FieldStart("expiring_at") - s.ExpiringAt.Encode(e) + if s.NextResolver.Set { + e.FieldStart("next_resolver") + s.NextResolver.Encode(e) } } { - if s.Item.Set { - e.FieldStart("item") - s.Item.Encode(e) + e.FieldStart("sites") + e.ArrStart() + for _, elem := range s.Sites { + e.Str(elem) + } + e.ArrEnd() + } + { + if s.Storage.Set { + e.FieldStart("storage") + s.Storage.Encode(e) + } + } + { + if s.Picture.Set { + e.FieldStart("picture") + s.Picture.Encode(e) } } } -var jsonFieldsNameOfDomainInfo = [3]string{ - 0: "name", - 1: "expiring_at", - 2: "item", +var jsonFieldsNameOfDnsRecord = [5]string{ + 0: "wallet", + 1: "next_resolver", + 2: "sites", + 3: "storage", + 4: "picture", } -// Decode decodes DomainInfo from json. -func (s *DomainInfo) Decode(d *jx.Decoder) error { +// Decode decodes DnsRecord from json. +func (s *DnsRecord) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DomainInfo to nil") + return errors.New("invalid: unable to decode DnsRecord to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "name": - requiredBitSet[0] |= 1 << 0 + case "wallet": if err := func() error { - v, err := d.Str() - s.Name = string(v) - if err != nil { + s.Wallet.Reset() + if err := s.Wallet.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"name\"") + return errors.Wrap(err, "decode field \"wallet\"") } - case "expiring_at": + case "next_resolver": if err := func() error { - s.ExpiringAt.Reset() - if err := s.ExpiringAt.Decode(d); err != nil { + s.NextResolver.Reset() + if err := s.NextResolver.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"expiring_at\"") + return errors.Wrap(err, "decode field \"next_resolver\"") } - case "item": + case "sites": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Item.Reset() - if err := s.Item.Decode(d); err != nil { + s.Sites = 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.Sites = append(s.Sites, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"item\"") + return errors.Wrap(err, "decode field \"sites\"") + } + case "storage": + if err := func() error { + s.Storage.Reset() + if err := s.Storage.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"storage\"") + } + case "picture": + if err := func() error { + s.Picture.Reset() + if err := s.Picture.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"picture\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DomainInfo") + return errors.Wrap(err, "decode DnsRecord") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000100, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -14850,8 +14810,8 @@ func (s *DomainInfo) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDomainInfo) { - name = jsonFieldsNameOfDomainInfo[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDnsRecord) { + name = jsonFieldsNameOfDnsRecord[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -14872,81 +14832,136 @@ func (s *DomainInfo) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DomainInfo) MarshalJSON() ([]byte, error) { +func (s *DnsRecord) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DomainInfo) UnmarshalJSON(data []byte) error { +func (s *DnsRecord) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DomainNames) Encode(e *jx.Encoder) { +func (s *DomainBid) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DomainNames) encodeFields(e *jx.Encoder) { +func (s *DomainBid) encodeFields(e *jx.Encoder) { { - e.FieldStart("domains") - e.ArrStart() - for _, elem := range s.Domains { - e.Str(elem) - } - e.ArrEnd() + e.FieldStart("success") + e.Bool(s.Success) + } + { + e.FieldStart("value") + e.Int64(s.Value) + } + { + e.FieldStart("txTime") + e.Int64(s.TxTime) + } + { + e.FieldStart("txHash") + e.Str(s.TxHash) + } + { + e.FieldStart("bidder") + s.Bidder.Encode(e) } } -var jsonFieldsNameOfDomainNames = [1]string{ - 0: "domains", +var jsonFieldsNameOfDomainBid = [5]string{ + 0: "success", + 1: "value", + 2: "txTime", + 3: "txHash", + 4: "bidder", } -// Decode decodes DomainNames from json. -func (s *DomainNames) Decode(d *jx.Decoder) error { +// Decode decodes DomainBid from json. +func (s *DomainBid) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DomainNames to nil") + return errors.New("invalid: unable to decode DomainBid to nil") } var requiredBitSet [1]uint8 + s.setDefaults() if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "domains": + case "success": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Domains = 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.Domains = append(s.Domains, elem) - return nil - }); err != nil { + v, err := d.Bool() + s.Success = bool(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"domains\"") + return errors.Wrap(err, "decode field \"success\"") + } + case "value": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int64() + s.Value = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"value\"") + } + case "txTime": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int64() + s.TxTime = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"txTime\"") + } + case "txHash": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Str() + s.TxHash = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"txHash\"") + } + case "bidder": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + if err := s.Bidder.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"bidder\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DomainNames") + return errors.Wrap(err, "decode DomainBid") } // 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. @@ -14958,8 +14973,8 @@ func (s *DomainNames) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDomainNames) { - name = jsonFieldsNameOfDomainNames[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDomainBid) { + name = jsonFieldsNameOfDomainBid[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -14980,101 +14995,79 @@ func (s *DomainNames) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DomainNames) MarshalJSON() ([]byte, error) { +func (s *DomainBid) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DomainNames) UnmarshalJSON(data []byte) error { +func (s *DomainBid) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *DomainRenewAction) Encode(e *jx.Encoder) { +func (s *DomainBids) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *DomainRenewAction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("domain") - e.Str(s.Domain) - } - { - e.FieldStart("contract_address") - e.Str(s.ContractAddress) - } +func (s *DomainBids) encodeFields(e *jx.Encoder) { { - e.FieldStart("renewer") - s.Renewer.Encode(e) + e.FieldStart("data") + e.ArrStart() + for _, elem := range s.Data { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfDomainRenewAction = [3]string{ - 0: "domain", - 1: "contract_address", - 2: "renewer", +var jsonFieldsNameOfDomainBids = [1]string{ + 0: "data", } -// Decode decodes DomainRenewAction from json. -func (s *DomainRenewAction) Decode(d *jx.Decoder) error { +// Decode decodes DomainBids from json. +func (s *DomainBids) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode DomainRenewAction to nil") + return errors.New("invalid: unable to decode DomainBids to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "domain": + case "data": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Domain = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"domain\"") - } - case "contract_address": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Str() - s.ContractAddress = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"contract_address\"") - } - case "renewer": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - if err := s.Renewer.Decode(d); err != nil { + s.Data = make([]DomainBid, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem DomainBid + if err := elem.Decode(d); err != nil { + return err + } + s.Data = append(s.Data, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"renewer\"") + return errors.Wrap(err, "decode field \"data\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode DomainRenewAction") + return errors.Wrap(err, "decode DomainBids") } // 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. @@ -15086,8 +15079,8 @@ func (s *DomainRenewAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfDomainRenewAction) { - name = jsonFieldsNameOfDomainRenewAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDomainBids) { + name = jsonFieldsNameOfDomainBids[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15108,120 +15101,103 @@ func (s *DomainRenewAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *DomainRenewAction) MarshalJSON() ([]byte, error) { +func (s *DomainBids) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *DomainRenewAction) UnmarshalJSON(data []byte) error { +func (s *DomainBids) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *EcPreview) Encode(e *jx.Encoder) { +func (s *DomainInfo) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *EcPreview) encodeFields(e *jx.Encoder) { - { - e.FieldStart("id") - e.Int32(s.ID) - } +func (s *DomainInfo) encodeFields(e *jx.Encoder) { { - e.FieldStart("symbol") - e.Str(s.Symbol) + e.FieldStart("name") + e.Str(s.Name) } { - e.FieldStart("decimals") - e.Int(s.Decimals) + if s.ExpiringAt.Set { + e.FieldStart("expiring_at") + s.ExpiringAt.Encode(e) + } } { - e.FieldStart("image") - e.Str(s.Image) + if s.Item.Set { + e.FieldStart("item") + s.Item.Encode(e) + } } } -var jsonFieldsNameOfEcPreview = [4]string{ - 0: "id", - 1: "symbol", - 2: "decimals", - 3: "image", +var jsonFieldsNameOfDomainInfo = [3]string{ + 0: "name", + 1: "expiring_at", + 2: "item", } -// Decode decodes EcPreview from json. -func (s *EcPreview) Decode(d *jx.Decoder) error { +// Decode decodes DomainInfo from json. +func (s *DomainInfo) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode EcPreview to nil") + return errors.New("invalid: unable to decode DomainInfo to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "id": + case "name": requiredBitSet[0] |= 1 << 0 - if err := func() error { - v, err := d.Int32() - s.ID = int32(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"id\"") - } - case "symbol": - requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.Symbol = string(v) + s.Name = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"symbol\"") + return errors.Wrap(err, "decode field \"name\"") } - case "decimals": - requiredBitSet[0] |= 1 << 2 + case "expiring_at": if err := func() error { - v, err := d.Int() - s.Decimals = int(v) - if err != nil { + s.ExpiringAt.Reset() + if err := s.ExpiringAt.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"decimals\"") + return errors.Wrap(err, "decode field \"expiring_at\"") } - case "image": - requiredBitSet[0] |= 1 << 3 + case "item": if err := func() error { - v, err := d.Str() - s.Image = string(v) - if err != nil { + s.Item.Reset() + if err := s.Item.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"image\"") + return errors.Wrap(err, "decode field \"item\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode EcPreview") + return errors.Wrap(err, "decode DomainInfo") } // 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. @@ -15233,8 +15209,8 @@ func (s *EcPreview) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfEcPreview) { - name = jsonFieldsNameOfEcPreview[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfDomainInfo) { + name = jsonFieldsNameOfDomainInfo[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15255,84 +15231,81 @@ func (s *EcPreview) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *EcPreview) MarshalJSON() ([]byte, error) { +func (s *DomainInfo) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *EcPreview) UnmarshalJSON(data []byte) error { +func (s *DomainInfo) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ElectionsDepositStakeAction) Encode(e *jx.Encoder) { +func (s *DomainNames) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ElectionsDepositStakeAction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("amount") - e.Int64(s.Amount) - } +func (s *DomainNames) encodeFields(e *jx.Encoder) { { - e.FieldStart("staker") - s.Staker.Encode(e) + e.FieldStart("domains") + e.ArrStart() + for _, elem := range s.Domains { + e.Str(elem) + } + e.ArrEnd() } } -var jsonFieldsNameOfElectionsDepositStakeAction = [2]string{ - 0: "amount", - 1: "staker", +var jsonFieldsNameOfDomainNames = [1]string{ + 0: "domains", } -// Decode decodes ElectionsDepositStakeAction from json. -func (s *ElectionsDepositStakeAction) Decode(d *jx.Decoder) error { +// Decode decodes DomainNames from json. +func (s *DomainNames) 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 DomainNames to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "amount": + case "domains": requiredBitSet[0] |= 1 << 0 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 "staker": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - if err := s.Staker.Decode(d); err != nil { + s.Domains = 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.Domains = append(s.Domains, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"staker\"") + return errors.Wrap(err, "decode field \"domains\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ElectionsDepositStakeAction") + return errors.Wrap(err, "decode DomainNames") } // 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. @@ -15344,8 +15317,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(jsonFieldsNameOfDomainNames) { + name = jsonFieldsNameOfDomainNames[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15366,84 +15339,101 @@ func (s *ElectionsDepositStakeAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ElectionsDepositStakeAction) MarshalJSON() ([]byte, error) { +func (s *DomainNames) 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 *DomainNames) 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 *DomainRenewAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ElectionsRecoverStakeAction) encodeFields(e *jx.Encoder) { +func (s *DomainRenewAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("amount") - e.Int64(s.Amount) + e.FieldStart("domain") + e.Str(s.Domain) } { - e.FieldStart("staker") - s.Staker.Encode(e) + e.FieldStart("contract_address") + e.Str(s.ContractAddress) + } + { + e.FieldStart("renewer") + s.Renewer.Encode(e) } } -var jsonFieldsNameOfElectionsRecoverStakeAction = [2]string{ - 0: "amount", - 1: "staker", +var jsonFieldsNameOfDomainRenewAction = [3]string{ + 0: "domain", + 1: "contract_address", + 2: "renewer", } -// Decode decodes ElectionsRecoverStakeAction from json. -func (s *ElectionsRecoverStakeAction) Decode(d *jx.Decoder) error { +// Decode decodes DomainRenewAction from json. +func (s *DomainRenewAction) 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 DomainRenewAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "amount": + case "domain": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.Amount = int64(v) + v, err := d.Str() + s.Domain = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") + return errors.Wrap(err, "decode field \"domain\"") } - case "staker": + case "contract_address": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Staker.Decode(d); err != nil { + v, err := d.Str() + s.ContractAddress = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"staker\"") + return errors.Wrap(err, "decode field \"contract_address\"") } - default: - return d.Skip() - } + case "renewer": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.Renewer.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"renewer\"") + } + default: + return d.Skip() + } return nil }); err != nil { - return errors.Wrap(err, "decode ElectionsRecoverStakeAction") + return errors.Wrap(err, "decode DomainRenewAction") } // 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. @@ -15455,8 +15445,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(jsonFieldsNameOfDomainRenewAction) { + name = jsonFieldsNameOfDomainRenewAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15477,69 +15467,120 @@ func (s *ElectionsRecoverStakeAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ElectionsRecoverStakeAction) MarshalJSON() ([]byte, error) { +func (s *DomainRenewAction) 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 *DomainRenewAction) 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 *EcPreview) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *EmulateMessageToAccountEventReq) encodeFields(e *jx.Encoder) { +func (s *EcPreview) encodeFields(e *jx.Encoder) { { - e.FieldStart("boc") - e.Str(s.Boc) + e.FieldStart("id") + e.Int32(s.ID) + } + { + e.FieldStart("symbol") + e.Str(s.Symbol) + } + { + e.FieldStart("decimals") + e.Int(s.Decimals) + } + { + e.FieldStart("image") + e.Str(s.Image) } } -var jsonFieldsNameOfEmulateMessageToAccountEventReq = [1]string{ - 0: "boc", +var jsonFieldsNameOfEcPreview = [4]string{ + 0: "id", + 1: "symbol", + 2: "decimals", + 3: "image", } -// Decode decodes EmulateMessageToAccountEventReq from json. -func (s *EmulateMessageToAccountEventReq) 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 EmulateMessageToAccountEventReq 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 "boc": + case "id": requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int32() + s.ID = int32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"id\"") + } + case "symbol": + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.Boc = string(v) + s.Symbol = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"boc\"") + 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 EmulateMessageToAccountEventReq") + return errors.Wrap(err, "decode EcPreview") } // 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. @@ -15551,8 +15592,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(jsonFieldsNameOfEcPreview) { + name = jsonFieldsNameOfEcPreview[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15573,69 +15614,84 @@ func (s *EmulateMessageToAccountEventReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *EmulateMessageToAccountEventReq) 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 *EmulateMessageToAccountEventReq) 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 *EmulateMessageToEventReq) Encode(e *jx.Encoder) { +func (s *ElectionsDepositStakeAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *EmulateMessageToEventReq) encodeFields(e *jx.Encoder) { +func (s *ElectionsDepositStakeAction) 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 jsonFieldsNameOfEmulateMessageToEventReq = [1]string{ - 0: "boc", +var jsonFieldsNameOfElectionsDepositStakeAction = [2]string{ + 0: "amount", + 1: "staker", } -// Decode decodes EmulateMessageToEventReq from json. -func (s *EmulateMessageToEventReq) 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 EmulateMessageToEventReq to nil") + return errors.New("invalid: unable to decode ElectionsDepositStakeAction 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 EmulateMessageToEventReq") + return errors.Wrap(err, "decode ElectionsDepositStakeAction") } // 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. @@ -15647,8 +15703,8 @@ func (s *EmulateMessageToEventReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfEmulateMessageToEventReq) { - name = jsonFieldsNameOfEmulateMessageToEventReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfElectionsDepositStakeAction) { + name = jsonFieldsNameOfElectionsDepositStakeAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15669,69 +15725,84 @@ func (s *EmulateMessageToEventReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *EmulateMessageToEventReq) 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 *EmulateMessageToEventReq) 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 *EmulateMessageToTraceReq) Encode(e *jx.Encoder) { +func (s *ElectionsRecoverStakeAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *EmulateMessageToTraceReq) 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 jsonFieldsNameOfEmulateMessageToTraceReq = [1]string{ - 0: "boc", +var jsonFieldsNameOfElectionsRecoverStakeAction = [2]string{ + 0: "amount", + 1: "staker", } -// Decode decodes EmulateMessageToTraceReq from json. -func (s *EmulateMessageToTraceReq) 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 EmulateMessageToTraceReq 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 EmulateMessageToTraceReq") + 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. @@ -15743,8 +15814,8 @@ func (s *EmulateMessageToTraceReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfEmulateMessageToTraceReq) { - name = jsonFieldsNameOfEmulateMessageToTraceReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfElectionsRecoverStakeAction) { + name = jsonFieldsNameOfElectionsRecoverStakeAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15765,52 +15836,41 @@ func (s *EmulateMessageToTraceReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *EmulateMessageToTraceReq) 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 *EmulateMessageToTraceReq) 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 *EmulateMessageToWalletReq) Encode(e *jx.Encoder) { +func (s *EmulateMessageToAccountEventReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *EmulateMessageToWalletReq) encodeFields(e *jx.Encoder) { +func (s *EmulateMessageToAccountEventReq) encodeFields(e *jx.Encoder) { { e.FieldStart("boc") e.Str(s.Boc) } - { - if s.Params != nil { - e.FieldStart("params") - e.ArrStart() - for _, elem := range s.Params { - elem.Encode(e) - } - e.ArrEnd() - } - } } -var jsonFieldsNameOfEmulateMessageToWalletReq = [2]string{ +var jsonFieldsNameOfEmulateMessageToAccountEventReq = [1]string{ 0: "boc", - 1: "params", } -// Decode decodes EmulateMessageToWalletReq from json. -func (s *EmulateMessageToWalletReq) 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 EmulateMessageToWalletReq to nil") + return errors.New("invalid: unable to decode EmulateMessageToAccountEventReq to nil") } var requiredBitSet [1]uint8 @@ -15828,29 +15888,12 @@ func (s *EmulateMessageToWalletReq) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"boc\"") } - case "params": - if err := func() error { - s.Params = make([]EmulateMessageToWalletReqParamsItem, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem EmulateMessageToWalletReqParamsItem - if err := elem.Decode(d); err != nil { - return err - } - s.Params = append(s.Params, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"params\"") - } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode EmulateMessageToWalletReq") + return errors.Wrap(err, "decode EmulateMessageToAccountEventReq") } // Validate required fields. var failures []validate.FieldError @@ -15867,8 +15910,8 @@ func (s *EmulateMessageToWalletReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfEmulateMessageToWalletReq) { - name = jsonFieldsNameOfEmulateMessageToWalletReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfEmulateMessageToAccountEventReq) { + name = jsonFieldsNameOfEmulateMessageToAccountEventReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -15889,81 +15932,64 @@ func (s *EmulateMessageToWalletReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *EmulateMessageToWalletReq) MarshalJSON() ([]byte, error) { +func (s *EmulateMessageToAccountEventReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *EmulateMessageToWalletReq) UnmarshalJSON(data []byte) error { +func (s *EmulateMessageToAccountEventReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *EmulateMessageToWalletReqParamsItem) Encode(e *jx.Encoder) { +func (s *EmulateMessageToEventReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *EmulateMessageToWalletReqParamsItem) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } +func (s *EmulateMessageToEventReq) encodeFields(e *jx.Encoder) { { - if s.Balance.Set { - e.FieldStart("balance") - s.Balance.Encode(e) - } + e.FieldStart("boc") + e.Str(s.Boc) } } -var jsonFieldsNameOfEmulateMessageToWalletReqParamsItem = [2]string{ - 0: "address", - 1: "balance", +var jsonFieldsNameOfEmulateMessageToEventReq = [1]string{ + 0: "boc", } -// Decode decodes EmulateMessageToWalletReqParamsItem from json. -func (s *EmulateMessageToWalletReqParamsItem) Decode(d *jx.Decoder) error { +// Decode decodes EmulateMessageToEventReq from json. +func (s *EmulateMessageToEventReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode EmulateMessageToWalletReqParamsItem to nil") + return errors.New("invalid: unable to decode EmulateMessageToEventReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "boc": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.Address = string(v) + s.Boc = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") - } - case "balance": - if err := func() error { - s.Balance.Reset() - if err := s.Balance.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"balance\"") + return errors.Wrap(err, "decode field \"boc\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode EmulateMessageToWalletReqParamsItem") + return errors.Wrap(err, "decode EmulateMessageToEventReq") } // Validate required fields. var failures []validate.FieldError @@ -15980,8 +16006,8 @@ func (s *EmulateMessageToWalletReqParamsItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfEmulateMessageToWalletReqParamsItem) { - name = jsonFieldsNameOfEmulateMessageToWalletReqParamsItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfEmulateMessageToEventReq) { + name = jsonFieldsNameOfEmulateMessageToEventReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16002,86 +16028,69 @@ func (s *EmulateMessageToWalletReqParamsItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *EmulateMessageToWalletReqParamsItem) MarshalJSON() ([]byte, error) { +func (s *EmulateMessageToEventReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *EmulateMessageToWalletReqParamsItem) UnmarshalJSON(data []byte) error { +func (s *EmulateMessageToEventReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *EncryptedComment) Encode(e *jx.Encoder) { +func (s *EmulateMessageToTraceReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *EncryptedComment) encodeFields(e *jx.Encoder) { - { - e.FieldStart("encryption_type") - e.Str(s.EncryptionType) - } +func (s *EmulateMessageToTraceReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("cipher_text") - e.Str(s.CipherText) + e.FieldStart("boc") + e.Str(s.Boc) } } -var jsonFieldsNameOfEncryptedComment = [2]string{ - 0: "encryption_type", - 1: "cipher_text", +var jsonFieldsNameOfEmulateMessageToTraceReq = [1]string{ + 0: "boc", } -// Decode decodes EncryptedComment from json. -func (s *EncryptedComment) Decode(d *jx.Decoder) error { +// Decode decodes EmulateMessageToTraceReq from json. +func (s *EmulateMessageToTraceReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode EncryptedComment to nil") + return errors.New("invalid: unable to decode EmulateMessageToTraceReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "encryption_type": + case "boc": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.EncryptionType = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"encryption_type\"") - } - case "cipher_text": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Str() - s.CipherText = string(v) + s.Boc = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"cipher_text\"") + return errors.Wrap(err, "decode field \"boc\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode EncryptedComment") + return errors.Wrap(err, "decode EmulateMessageToTraceReq") } // 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. @@ -16093,8 +16102,8 @@ func (s *EncryptedComment) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfEncryptedComment) { - name = jsonFieldsNameOfEncryptedComment[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfEmulateMessageToTraceReq) { + name = jsonFieldsNameOfEmulateMessageToTraceReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16115,81 +16124,92 @@ func (s *EncryptedComment) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *EncryptedComment) MarshalJSON() ([]byte, error) { +func (s *EmulateMessageToTraceReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *EncryptedComment) UnmarshalJSON(data []byte) error { +func (s *EmulateMessageToTraceReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Error) Encode(e *jx.Encoder) { +func (s *EmulateMessageToWalletReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Error) encodeFields(e *jx.Encoder) { +func (s *EmulateMessageToWalletReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("error") - e.Str(s.Error) + e.FieldStart("boc") + e.Str(s.Boc) } { - if s.ErrorCode.Set { - e.FieldStart("error_code") - s.ErrorCode.Encode(e) + if s.Params != nil { + e.FieldStart("params") + e.ArrStart() + for _, elem := range s.Params { + elem.Encode(e) + } + e.ArrEnd() } } } -var jsonFieldsNameOfError = [2]string{ - 0: "error", - 1: "error_code", +var jsonFieldsNameOfEmulateMessageToWalletReq = [2]string{ + 0: "boc", + 1: "params", } -// Decode decodes Error from json. -func (s *Error) Decode(d *jx.Decoder) error { +// Decode decodes EmulateMessageToWalletReq from json. +func (s *EmulateMessageToWalletReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Error to nil") + return errors.New("invalid: unable to decode EmulateMessageToWalletReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "error": + case "boc": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.Error = string(v) + s.Boc = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"error\"") + return errors.Wrap(err, "decode field \"boc\"") } - case "error_code": + case "params": if err := func() error { - s.ErrorCode.Reset() - if err := s.ErrorCode.Decode(d); err != nil { + s.Params = make([]EmulateMessageToWalletReqParamsItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem EmulateMessageToWalletReqParamsItem + if err := elem.Decode(d); err != nil { + return err + } + s.Params = append(s.Params, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"error_code\"") + return errors.Wrap(err, "decode field \"params\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Error") + return errors.Wrap(err, "decode EmulateMessageToWalletReq") } // Validate required fields. var failures []validate.FieldError @@ -16206,8 +16226,8 @@ func (s *Error) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfError) { - name = jsonFieldsNameOfError[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfEmulateMessageToWalletReq) { + name = jsonFieldsNameOfEmulateMessageToWalletReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16228,243 +16248,86 @@ func (s *Error) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Error) MarshalJSON() ([]byte, error) { +func (s *EmulateMessageToWalletReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Error) UnmarshalJSON(data []byte) error { +func (s *EmulateMessageToWalletReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Event) Encode(e *jx.Encoder) { +func (s *EmulateMessageToWalletReqParamsItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Event) encodeFields(e *jx.Encoder) { - { - e.FieldStart("event_id") - e.Str(s.EventID) - } - { - e.FieldStart("timestamp") - e.Int64(s.Timestamp) - } - { - e.FieldStart("actions") - e.ArrStart() - for _, elem := range s.Actions { - elem.Encode(e) - } - e.ArrEnd() - } - { - e.FieldStart("value_flow") - e.ArrStart() - for _, elem := range s.ValueFlow { - elem.Encode(e) - } - e.ArrEnd() - } - { - e.FieldStart("is_scam") - e.Bool(s.IsScam) - } - { - e.FieldStart("lt") - e.Int64(s.Lt) - } - { - e.FieldStart("in_progress") - e.Bool(s.InProgress) - } - { - e.FieldStart("progress") - e.Float32(s.Progress) - } +func (s *EmulateMessageToWalletReqParamsItem) encodeFields(e *jx.Encoder) { { - if s.LastSliceID.Set { - e.FieldStart("last_slice_id") - s.LastSliceID.Encode(e) - } + e.FieldStart("address") + e.Str(s.Address) } { - if s.ExtMsgHash.Set { - e.FieldStart("ext_msg_hash") - s.ExtMsgHash.Encode(e) + if s.Balance.Set { + e.FieldStart("balance") + s.Balance.Encode(e) } } } -var jsonFieldsNameOfEvent = [10]string{ - 0: "event_id", - 1: "timestamp", - 2: "actions", - 3: "value_flow", - 4: "is_scam", - 5: "lt", - 6: "in_progress", - 7: "progress", - 8: "last_slice_id", - 9: "ext_msg_hash", +var jsonFieldsNameOfEmulateMessageToWalletReqParamsItem = [2]string{ + 0: "address", + 1: "balance", } -// Decode decodes Event from json. -func (s *Event) Decode(d *jx.Decoder) error { +// Decode decodes EmulateMessageToWalletReqParamsItem from json. +func (s *EmulateMessageToWalletReqParamsItem) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Event to nil") + return errors.New("invalid: unable to decode EmulateMessageToWalletReqParamsItem 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 "event_id": + case "address": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.EventID = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"event_id\"") - } - case "timestamp": - requiredBitSet[0] |= 1 << 1 - 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 "actions": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - s.Actions = make([]Action, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem Action - if err := elem.Decode(d); err != nil { - return err - } - s.Actions = append(s.Actions, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"actions\"") - } - case "value_flow": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - s.ValueFlow = make([]ValueFlow, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem ValueFlow - if err := elem.Decode(d); err != nil { - return err - } - s.ValueFlow = append(s.ValueFlow, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"value_flow\"") - } - case "is_scam": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Bool() - s.IsScam = bool(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"is_scam\"") - } - case "lt": - requiredBitSet[0] |= 1 << 5 - 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 "in_progress": - requiredBitSet[0] |= 1 << 6 - if err := func() error { - v, err := d.Bool() - s.InProgress = bool(v) - if err != nil { - return err - } - return nil - }(); 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) + s.Address = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"progress\"") - } - case "last_slice_id": - if err := func() error { - s.LastSliceID.Reset() - if err := s.LastSliceID.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"last_slice_id\"") + return errors.Wrap(err, "decode field \"address\"") } - case "ext_msg_hash": + case "balance": if err := func() error { - s.ExtMsgHash.Reset() - if err := s.ExtMsgHash.Decode(d); err != nil { + s.Balance.Reset() + if err := s.Balance.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ext_msg_hash\"") + return errors.Wrap(err, "decode field \"balance\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Event") + return errors.Wrap(err, "decode EmulateMessageToWalletReqParamsItem") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [2]uint8{ - 0b11111111, - 0b00000000, + 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. @@ -16476,8 +16339,8 @@ func (s *Event) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfEvent) { - name = jsonFieldsNameOfEvent[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfEmulateMessageToWalletReqParamsItem) { + name = jsonFieldsNameOfEmulateMessageToWalletReqParamsItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16498,79 +16361,81 @@ func (s *Event) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Event) MarshalJSON() ([]byte, error) { +func (s *EmulateMessageToWalletReqParamsItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Event) UnmarshalJSON(data []byte) error { +func (s *EmulateMessageToWalletReqParamsItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ExecGetMethodArg) Encode(e *jx.Encoder) { +func (s *EncryptedComment) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ExecGetMethodArg) encodeFields(e *jx.Encoder) { +func (s *EncryptedComment) encodeFields(e *jx.Encoder) { { - e.FieldStart("type") - s.Type.Encode(e) + e.FieldStart("encryption_type") + e.Str(s.EncryptionType) } { - e.FieldStart("value") - e.Str(s.Value) + e.FieldStart("cipher_text") + e.Str(s.CipherText) } } -var jsonFieldsNameOfExecGetMethodArg = [2]string{ - 0: "type", - 1: "value", +var jsonFieldsNameOfEncryptedComment = [2]string{ + 0: "encryption_type", + 1: "cipher_text", } -// Decode decodes ExecGetMethodArg from json. -func (s *ExecGetMethodArg) Decode(d *jx.Decoder) error { +// Decode decodes EncryptedComment from json. +func (s *EncryptedComment) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ExecGetMethodArg to nil") + return errors.New("invalid: unable to decode EncryptedComment to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "type": + case "encryption_type": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Type.Decode(d); err != nil { + v, err := d.Str() + s.EncryptionType = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"type\"") + return errors.Wrap(err, "decode field \"encryption_type\"") } - case "value": + case "cipher_text": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.Value = string(v) + s.CipherText = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"value\"") + return errors.Wrap(err, "decode field \"cipher_text\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ExecGetMethodArg") + return errors.Wrap(err, "decode EncryptedComment") } // Validate required fields. var failures []validate.FieldError @@ -16587,8 +16452,8 @@ func (s *ExecGetMethodArg) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfExecGetMethodArg) { - name = jsonFieldsNameOfExecGetMethodArg[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfEncryptedComment) { + name = jsonFieldsNameOfEncryptedComment[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16609,124 +16474,81 @@ func (s *ExecGetMethodArg) Decode(d *jx.Decoder) error { } // 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) { +func (s *EncryptedComment) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ExecGetMethodArgType) UnmarshalJSON(data []byte) error { +func (s *EncryptedComment) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ExecGetMethodWithBodyForBlockchainAccountReq) Encode(e *jx.Encoder) { +func (s *Error) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ExecGetMethodWithBodyForBlockchainAccountReq) encodeFields(e *jx.Encoder) { +func (s *Error) encodeFields(e *jx.Encoder) { { - e.FieldStart("args") - e.ArrStart() - for _, elem := range s.Args { - elem.Encode(e) + e.FieldStart("error") + e.Str(s.Error) + } + { + if s.ErrorCode.Set { + e.FieldStart("error_code") + s.ErrorCode.Encode(e) } - e.ArrEnd() } } -var jsonFieldsNameOfExecGetMethodWithBodyForBlockchainAccountReq = [1]string{ - 0: "args", +var jsonFieldsNameOfError = [2]string{ + 0: "error", + 1: "error_code", } -// Decode decodes ExecGetMethodWithBodyForBlockchainAccountReq from json. -func (s *ExecGetMethodWithBodyForBlockchainAccountReq) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode ExecGetMethodWithBodyForBlockchainAccountReq to nil") +// Decode decodes Error from json. +func (s *Error) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode Error to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "args": + case "error": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Args = make([]ExecGetMethodArg, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem ExecGetMethodArg - if err := elem.Decode(d); err != nil { - return err - } - s.Args = append(s.Args, elem) - return nil - }); err != nil { + v, err := d.Str() + s.Error = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"args\"") + 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() } return nil }); err != nil { - return errors.Wrap(err, "decode ExecGetMethodWithBodyForBlockchainAccountReq") + return errors.Wrap(err, "decode Error") } // Validate required fields. var failures []validate.FieldError @@ -16743,8 +16565,8 @@ func (s *ExecGetMethodWithBodyForBlockchainAccountReq) Decode(d *jx.Decoder) err bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfExecGetMethodWithBodyForBlockchainAccountReq) { - name = jsonFieldsNameOfExecGetMethodWithBodyForBlockchainAccountReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfError) { + name = jsonFieldsNameOfError[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16765,84 +16587,243 @@ func (s *ExecGetMethodWithBodyForBlockchainAccountReq) Decode(d *jx.Decoder) err } // MarshalJSON implements stdjson.Marshaler. -func (s *ExecGetMethodWithBodyForBlockchainAccountReq) MarshalJSON() ([]byte, error) { +func (s *Error) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ExecGetMethodWithBodyForBlockchainAccountReq) UnmarshalJSON(data []byte) error { +func (s *Error) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ExtraCurrency) Encode(e *jx.Encoder) { +func (s *Event) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ExtraCurrency) encodeFields(e *jx.Encoder) { +func (s *Event) encodeFields(e *jx.Encoder) { { - e.FieldStart("amount") - e.Str(s.Amount) + e.FieldStart("event_id") + e.Str(s.EventID) } { - e.FieldStart("preview") - s.Preview.Encode(e) + e.FieldStart("timestamp") + e.Int64(s.Timestamp) + } + { + e.FieldStart("actions") + e.ArrStart() + for _, elem := range s.Actions { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("value_flow") + e.ArrStart() + for _, elem := range s.ValueFlow { + elem.Encode(e) + } + e.ArrEnd() + } + { + e.FieldStart("is_scam") + e.Bool(s.IsScam) + } + { + e.FieldStart("lt") + e.Int64(s.Lt) + } + { + e.FieldStart("in_progress") + e.Bool(s.InProgress) + } + { + e.FieldStart("progress") + e.Float32(s.Progress) + } + { + if s.LastSliceID.Set { + e.FieldStart("last_slice_id") + s.LastSliceID.Encode(e) + } + } + { + if s.ExtMsgHash.Set { + e.FieldStart("ext_msg_hash") + s.ExtMsgHash.Encode(e) + } } } -var jsonFieldsNameOfExtraCurrency = [2]string{ - 0: "amount", - 1: "preview", +var jsonFieldsNameOfEvent = [10]string{ + 0: "event_id", + 1: "timestamp", + 2: "actions", + 3: "value_flow", + 4: "is_scam", + 5: "lt", + 6: "in_progress", + 7: "progress", + 8: "last_slice_id", + 9: "ext_msg_hash", } -// Decode decodes ExtraCurrency from json. -func (s *ExtraCurrency) Decode(d *jx.Decoder) error { +// Decode decodes Event from json. +func (s *Event) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ExtraCurrency to nil") + return errors.New("invalid: unable to decode Event 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 "amount": + case "event_id": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.Amount = string(v) + s.EventID = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") + return errors.Wrap(err, "decode field \"event_id\"") } - case "preview": + case "timestamp": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Preview.Decode(d); err != nil { + v, err := d.Int64() + s.Timestamp = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"preview\"") + return errors.Wrap(err, "decode field \"timestamp\"") + } + case "actions": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + s.Actions = make([]Action, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem Action + if err := elem.Decode(d); err != nil { + return err + } + s.Actions = append(s.Actions, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"actions\"") + } + case "value_flow": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + s.ValueFlow = make([]ValueFlow, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ValueFlow + if err := elem.Decode(d); err != nil { + return err + } + s.ValueFlow = append(s.ValueFlow, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"value_flow\"") + } + case "is_scam": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Bool() + s.IsScam = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"is_scam\"") + } + case "lt": + requiredBitSet[0] |= 1 << 5 + 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 "in_progress": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + v, err := d.Bool() + s.InProgress = bool(v) + if err != nil { + return err + } + return nil + }(); 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\"") + } + case "last_slice_id": + if err := func() error { + s.LastSliceID.Reset() + if err := s.LastSliceID.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"last_slice_id\"") + } + case "ext_msg_hash": + if err := func() error { + s.ExtMsgHash.Reset() + if err := s.ExtMsgHash.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ext_msg_hash\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ExtraCurrency") + return errors.Wrap(err, "decode Event") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ - 0b00000011, + 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. @@ -16854,8 +16835,8 @@ func (s *ExtraCurrency) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfExtraCurrency) { - name = jsonFieldsNameOfExtraCurrency[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfEvent) { + name = jsonFieldsNameOfEvent[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -16876,148 +16857,84 @@ func (s *ExtraCurrency) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ExtraCurrency) MarshalJSON() ([]byte, error) { +func (s *Event) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ExtraCurrency) UnmarshalJSON(data []byte) error { +func (s *Event) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *ExtraCurrencyTransferAction) Encode(e *jx.Encoder) { +func (s *ExecGetMethodArg) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ExtraCurrencyTransferAction) encodeFields(e *jx.Encoder) { +func (s *ExecGetMethodArg) 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) - } - } - { - if s.EncryptedComment.Set { - e.FieldStart("encrypted_comment") - s.EncryptedComment.Encode(e) - } + e.FieldStart("type") + s.Type.Encode(e) } { - e.FieldStart("currency") - s.Currency.Encode(e) + e.FieldStart("value") + e.Str(s.Value) } } -var jsonFieldsNameOfExtraCurrencyTransferAction = [6]string{ - 0: "sender", - 1: "recipient", - 2: "amount", - 3: "comment", - 4: "encrypted_comment", - 5: "currency", +var jsonFieldsNameOfExecGetMethodArg = [2]string{ + 0: "type", + 1: "value", } -// Decode decodes ExtraCurrencyTransferAction from json. -func (s *ExtraCurrencyTransferAction) Decode(d *jx.Decoder) error { +// Decode decodes ExecGetMethodArg from json. +func (s *ExecGetMethodArg) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode ExtraCurrencyTransferAction to 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 "sender": + case "type": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Sender.Decode(d); err != nil { + if err := s.Type.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"sender\"") + return errors.Wrap(err, "decode field \"type\"") } - case "recipient": + case "value": 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.Value = 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 "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 "currency": - requiredBitSet[0] |= 1 << 5 - if err := func() error { - if err := s.Currency.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"currency\"") + return errors.Wrap(err, "decode field \"value\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ExtraCurrencyTransferAction") + return errors.Wrap(err, "decode ExecGetMethodArg") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00100111, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -17029,8 +16946,8 @@ func (s *ExtraCurrencyTransferAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfExtraCurrencyTransferAction) { - name = jsonFieldsNameOfExtraCurrencyTransferAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfExecGetMethodArg) { + name = jsonFieldsNameOfExecGetMethodArg[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17051,221 +16968,129 @@ func (s *ExtraCurrencyTransferAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ExtraCurrencyTransferAction) MarshalJSON() ([]byte, error) { +func (s *ExecGetMethodArg) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *ExtraCurrencyTransferAction) UnmarshalJSON(data []byte) error { +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 *FlawedJettonTransferAction) Encode(e *jx.Encoder) { +func (s *ExecGetMethodWithBodyForBlockchainAccountReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *FlawedJettonTransferAction) encodeFields(e *jx.Encoder) { - { - if s.Sender.Set { - e.FieldStart("sender") - s.Sender.Encode(e) - } - } - { - if s.Recipient.Set { - e.FieldStart("recipient") - s.Recipient.Encode(e) - } - } - { - e.FieldStart("senders_wallet") - e.Str(s.SendersWallet) - } - { - e.FieldStart("recipients_wallet") - e.Str(s.RecipientsWallet) - } - { - e.FieldStart("sent_amount") - e.Str(s.SentAmount) - } - { - e.FieldStart("received_amount") - e.Str(s.ReceivedAmount) - } - { - if s.Comment.Set { - e.FieldStart("comment") - s.Comment.Encode(e) - } - } - { - if s.EncryptedComment.Set { - e.FieldStart("encrypted_comment") - s.EncryptedComment.Encode(e) - } - } +func (s *ExecGetMethodWithBodyForBlockchainAccountReq) encodeFields(e *jx.Encoder) { { - if s.Refund.Set { - e.FieldStart("refund") - s.Refund.Encode(e) + e.FieldStart("args") + e.ArrStart() + for _, elem := range s.Args { + elem.Encode(e) } - } - { - e.FieldStart("jetton") - s.Jetton.Encode(e) + e.ArrEnd() } } -var jsonFieldsNameOfFlawedJettonTransferAction = [10]string{ - 0: "sender", - 1: "recipient", - 2: "senders_wallet", - 3: "recipients_wallet", - 4: "sent_amount", - 5: "received_amount", - 6: "comment", - 7: "encrypted_comment", - 8: "refund", - 9: "jetton", +var jsonFieldsNameOfExecGetMethodWithBodyForBlockchainAccountReq = [1]string{ + 0: "args", } -// Decode decodes FlawedJettonTransferAction from json. -func (s *FlawedJettonTransferAction) 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 FlawedJettonTransferAction to nil") + return errors.New("invalid: unable to decode ExecGetMethodWithBodyForBlockchainAccountReq 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 "sender": + case "args": + requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Sender.Reset() - if err := s.Sender.Decode(d); err != nil { + s.Args = make([]ExecGetMethodArg, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ExecGetMethodArg + if err := elem.Decode(d); err != nil { + return err + } + s.Args = append(s.Args, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"sender\"") - } - case "recipient": - if err := func() error { - s.Recipient.Reset() - if err := s.Recipient.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"recipient\"") - } - case "senders_wallet": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Str() - s.SendersWallet = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"senders_wallet\"") - } - case "recipients_wallet": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Str() - s.RecipientsWallet = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"recipients_wallet\"") - } - case "sent_amount": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Str() - s.SentAmount = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"sent_amount\"") - } - case "received_amount": - requiredBitSet[0] |= 1 << 5 - if err := func() error { - v, err := d.Str() - s.ReceivedAmount = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"received_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\"") - } - case "jetton": - requiredBitSet[1] |= 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\"") + return errors.Wrap(err, "decode field \"args\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode FlawedJettonTransferAction") + return errors.Wrap(err, "decode ExecGetMethodWithBodyForBlockchainAccountReq") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [2]uint8{ - 0b00111100, - 0b00000010, + 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. @@ -17277,8 +17102,8 @@ func (s *FlawedJettonTransferAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfFlawedJettonTransferAction) { - name = jsonFieldsNameOfFlawedJettonTransferAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfExecGetMethodWithBodyForBlockchainAccountReq) { + name = jsonFieldsNameOfExecGetMethodWithBodyForBlockchainAccountReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17299,79 +17124,84 @@ func (s *FlawedJettonTransferAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *FlawedJettonTransferAction) 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 *FlawedJettonTransferAction) 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 *FoundAccounts) Encode(e *jx.Encoder) { +func (s *ExtraCurrency) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *FoundAccounts) encodeFields(e *jx.Encoder) { +func (s *ExtraCurrency) encodeFields(e *jx.Encoder) { { - e.FieldStart("addresses") - e.ArrStart() - for _, elem := range s.Addresses { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("amount") + e.Str(s.Amount) + } + { + e.FieldStart("preview") + s.Preview.Encode(e) } } -var jsonFieldsNameOfFoundAccounts = [1]string{ - 0: "addresses", +var jsonFieldsNameOfExtraCurrency = [2]string{ + 0: "amount", + 1: "preview", } -// Decode decodes FoundAccounts from json. -func (s *FoundAccounts) 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 FoundAccounts 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 "addresses": + case "amount": requiredBitSet[0] |= 1 << 0 if err := func() error { - 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 { + v, err := d.Str() + s.Amount = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"addresses\"") + return errors.Wrap(err, "decode field \"amount\"") + } + case "preview": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Preview.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"preview\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode FoundAccounts") + return errors.Wrap(err, "decode ExtraCurrency") } // 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. @@ -17383,8 +17213,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(jsonFieldsNameOfExtraCurrency) { + name = jsonFieldsNameOfExtraCurrency[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17405,118 +17235,148 @@ func (s *FoundAccounts) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *FoundAccounts) 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 *FoundAccounts) 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 *FoundAccountsAddressesItem) Encode(e *jx.Encoder) { +func (s *ExtraCurrencyTransferAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *FoundAccountsAddressesItem) encodeFields(e *jx.Encoder) { +func (s *ExtraCurrencyTransferAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("address") - e.Str(s.Address) + e.FieldStart("sender") + s.Sender.Encode(e) } { - e.FieldStart("name") - e.Str(s.Name) + e.FieldStart("recipient") + s.Recipient.Encode(e) } { - e.FieldStart("preview") - e.Str(s.Preview) + e.FieldStart("amount") + e.Str(s.Amount) } { - e.FieldStart("trust") - s.Trust.Encode(e) + if s.Comment.Set { + e.FieldStart("comment") + s.Comment.Encode(e) + } + } + { + if s.EncryptedComment.Set { + e.FieldStart("encrypted_comment") + s.EncryptedComment.Encode(e) + } + } + { + e.FieldStart("currency") + s.Currency.Encode(e) } } -var jsonFieldsNameOfFoundAccountsAddressesItem = [4]string{ - 0: "address", - 1: "name", - 2: "preview", - 3: "trust", +var jsonFieldsNameOfExtraCurrencyTransferAction = [6]string{ + 0: "sender", + 1: "recipient", + 2: "amount", + 3: "comment", + 4: "encrypted_comment", + 5: "currency", } -// Decode decodes FoundAccountsAddressesItem from json. -func (s *FoundAccountsAddressesItem) 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 FoundAccountsAddressesItem to nil") + return errors.New("invalid: unable to decode ExtraCurrencyTransferAction to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "sender": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Address = string(v) - if err != nil { + if err := s.Sender.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") + return errors.Wrap(err, "decode field \"sender\"") } - case "name": + case "recipient": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.Name = string(v) - if err != nil { + if err := s.Recipient.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"name\"") + return errors.Wrap(err, "decode field \"recipient\"") } - case "preview": + case "amount": requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.Preview = string(v) + s.Amount = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"preview\"") + return errors.Wrap(err, "decode field \"amount\"") } - case "trust": - requiredBitSet[0] |= 1 << 3 + case "comment": if err := func() error { - if err := s.Trust.Decode(d); 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 \"trust\"") + return errors.Wrap(err, "decode field \"comment\"") } - default: - return d.Skip() - } + 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 "currency": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + if err := s.Currency.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"currency\"") + } + default: + return d.Skip() + } return nil }); err != nil { - return errors.Wrap(err, "decode FoundAccountsAddressesItem") + return errors.Wrap(err, "decode ExtraCurrencyTransferAction") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001111, + 0b00100111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -17528,8 +17388,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(jsonFieldsNameOfExtraCurrencyTransferAction) { + name = jsonFieldsNameOfExtraCurrencyTransferAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17550,206 +17410,221 @@ func (s *FoundAccountsAddressesItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *FoundAccountsAddressesItem) 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 *FoundAccountsAddressesItem) 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 *GasLimitPrices) Encode(e *jx.Encoder) { +func (s *FlawedJettonTransferAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GasLimitPrices) encodeFields(e *jx.Encoder) { +func (s *FlawedJettonTransferAction) encodeFields(e *jx.Encoder) { { - if s.SpecialGasLimit.Set { - e.FieldStart("special_gas_limit") - s.SpecialGasLimit.Encode(e) + if s.Sender.Set { + e.FieldStart("sender") + s.Sender.Encode(e) } } { - if s.FlatGasLimit.Set { - e.FieldStart("flat_gas_limit") - s.FlatGasLimit.Encode(e) + if s.Recipient.Set { + e.FieldStart("recipient") + s.Recipient.Encode(e) } } { - if s.FlatGasPrice.Set { - e.FieldStart("flat_gas_price") - s.FlatGasPrice.Encode(e) - } + e.FieldStart("senders_wallet") + e.Str(s.SendersWallet) } { - e.FieldStart("gas_price") - e.Int64(s.GasPrice) + e.FieldStart("recipients_wallet") + e.Str(s.RecipientsWallet) } { - e.FieldStart("gas_limit") - e.Int64(s.GasLimit) + e.FieldStart("sent_amount") + e.Str(s.SentAmount) } { - e.FieldStart("gas_credit") - e.Int64(s.GasCredit) + e.FieldStart("received_amount") + e.Str(s.ReceivedAmount) } { - 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) + if s.Refund.Set { + e.FieldStart("refund") + s.Refund.Encode(e) + } + } + { + e.FieldStart("jetton") + s.Jetton.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 jsonFieldsNameOfFlawedJettonTransferAction = [10]string{ + 0: "sender", + 1: "recipient", + 2: "senders_wallet", + 3: "recipients_wallet", + 4: "sent_amount", + 5: "received_amount", + 6: "comment", + 7: "encrypted_comment", + 8: "refund", + 9: "jetton", } -// Decode decodes GasLimitPrices from json. -func (s *GasLimitPrices) Decode(d *jx.Decoder) error { +// Decode decodes FlawedJettonTransferAction from json. +func (s *FlawedJettonTransferAction) 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 FlawedJettonTransferAction to nil") } var requiredBitSet [2]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "special_gas_limit": + case "sender": if err := func() error { - s.SpecialGasLimit.Reset() - if err := s.SpecialGasLimit.Decode(d); err != nil { + s.Sender.Reset() + if err := s.Sender.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"special_gas_limit\"") + return errors.Wrap(err, "decode field \"sender\"") } - case "flat_gas_limit": + case "recipient": if err := func() error { - s.FlatGasLimit.Reset() - if err := s.FlatGasLimit.Decode(d); err != nil { + s.Recipient.Reset() + if err := s.Recipient.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"flat_gas_limit\"") + return errors.Wrap(err, "decode field \"recipient\"") } - case "flat_gas_price": + case "senders_wallet": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.FlatGasPrice.Reset() - if err := s.FlatGasPrice.Decode(d); err != nil { + v, err := d.Str() + s.SendersWallet = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"flat_gas_price\"") + return errors.Wrap(err, "decode field \"senders_wallet\"") } - case "gas_price": + case "recipients_wallet": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Int64() - s.GasPrice = int64(v) + v, err := d.Str() + s.RecipientsWallet = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"gas_price\"") + return errors.Wrap(err, "decode field \"recipients_wallet\"") } - case "gas_limit": + case "sent_amount": requiredBitSet[0] |= 1 << 4 if err := func() error { - v, err := d.Int64() - s.GasLimit = int64(v) + v, err := d.Str() + s.SentAmount = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"gas_limit\"") + return errors.Wrap(err, "decode field \"sent_amount\"") } - case "gas_credit": + case "received_amount": requiredBitSet[0] |= 1 << 5 if err := func() error { - v, err := d.Int64() - s.GasCredit = int64(v) + v, err := d.Str() + s.ReceivedAmount = 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 \"received_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 "refund": if err := func() error { - v, err := d.Int64() - s.DeleteDueLimit = int64(v) - if err != nil { + s.Refund.Reset() + if err := s.Refund.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 \"refund\"") + } + case "jetton": + requiredBitSet[1] |= 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\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GasLimitPrices") + return errors.Wrap(err, "decode FlawedJettonTransferAction") } // Validate required fields. var failures []validate.FieldError for i, mask := range [2]uint8{ - 0b11111000, - 0b00000001, + 0b00111100, + 0b00000010, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -17761,8 +17636,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(jsonFieldsNameOfFlawedJettonTransferAction) { + name = jsonFieldsNameOfFlawedJettonTransferAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17783,99 +17658,79 @@ func (s *GasLimitPrices) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GasLimitPrices) MarshalJSON() ([]byte, error) { +func (s *FlawedJettonTransferAction) 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 *FlawedJettonTransferAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *GasRelayAction) Encode(e *jx.Encoder) { +func (s *FoundAccounts) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GasRelayAction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("amount") - e.Int64(s.Amount) - } - { - e.FieldStart("relayer") - s.Relayer.Encode(e) - } +func (s *FoundAccounts) encodeFields(e *jx.Encoder) { { - e.FieldStart("target") - s.Target.Encode(e) + e.FieldStart("addresses") + e.ArrStart() + for _, elem := range s.Addresses { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfGasRelayAction = [3]string{ - 0: "amount", - 1: "relayer", - 2: "target", +var jsonFieldsNameOfFoundAccounts = [1]string{ + 0: "addresses", } -// Decode decodes GasRelayAction from json. -func (s *GasRelayAction) 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 GasRelayAction 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 "amount": + case "addresses": requiredBitSet[0] |= 1 << 0 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 "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 { + 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 \"target\"") + return errors.Wrap(err, "decode field \"addresses\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GasRelayAction") + return errors.Wrap(err, "decode FoundAccounts") } // 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. @@ -17887,8 +17742,8 @@ func (s *GasRelayAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGasRelayAction) { - name = jsonFieldsNameOfGasRelayAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfFoundAccounts) { + name = jsonFieldsNameOfFoundAccounts[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -17909,192 +17764,118 @@ func (s *GasRelayAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GasRelayAction) 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 *GasRelayAction) 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 *GaslessConfig) Encode(e *jx.Encoder) { +func (s *FoundAccountsAddressesItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GaslessConfig) encodeFields(e *jx.Encoder) { +func (s *FoundAccountsAddressesItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("relay_address") - e.Str(s.RelayAddress) + e.FieldStart("address") + e.Str(s.Address) } { - e.FieldStart("gas_jettons") - e.ArrStart() - for _, elem := range s.GasJettons { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("name") + e.Str(s.Name) + } + { + e.FieldStart("preview") + e.Str(s.Preview) + } + { + e.FieldStart("trust") + s.Trust.Encode(e) } } -var jsonFieldsNameOfGaslessConfig = [2]string{ - 0: "relay_address", - 1: "gas_jettons", +var jsonFieldsNameOfFoundAccountsAddressesItem = [4]string{ + 0: "address", + 1: "name", + 2: "preview", + 3: "trust", } -// Decode decodes GaslessConfig from json. -func (s *GaslessConfig) 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 GaslessConfig 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 "relay_address": + case "address": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.RelayAddress = string(v) + s.Address = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"relay_address\"") + return errors.Wrap(err, "decode field \"address\"") } - case "gas_jettons": + case "name": 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 { + v, err := d.Str() + s.Name = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"gas_jettons\"") - } - default: - return d.Skip() - } - return nil - }); err != nil { - return errors.Wrap(err, "decode GaslessConfig") - } - // 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(jsonFieldsNameOfGaslessConfig) { - name = jsonFieldsNameOfGaslessConfig[fieldIdx] - } else { - name = strconv.Itoa(fieldIdx) - } - failures = append(failures, validate.FieldError{ - Name: name, - Error: validate.ErrFieldRequired, - }) - // Reset bit. - result &^= 1 << bitIdx + return errors.Wrap(err, "decode field \"name\"") } - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s *GaslessConfig) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GaslessConfig) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s *GaslessConfigGasJettonsItem) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *GaslessConfigGasJettonsItem) encodeFields(e *jx.Encoder) { - { - e.FieldStart("master_id") - e.Str(s.MasterID) - } -} - -var jsonFieldsNameOfGaslessConfigGasJettonsItem = [1]string{ - 0: "master_id", -} - -// Decode decodes GaslessConfigGasJettonsItem from json. -func (s *GaslessConfigGasJettonsItem) Decode(d *jx.Decoder) error { - if s == 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 "master_id": - requiredBitSet[0] |= 1 << 0 + case "preview": + requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.MasterID = string(v) + s.Preview = 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 \"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. @@ -18106,8 +17887,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) } @@ -18128,148 +17909,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) { { - if s.ThrowErrorIfNotEnoughJettons.Set { - e.FieldStart("throw_error_if_not_enough_jettons") - s.ThrowErrorIfNotEnoughJettons.Encode(e) + if s.SpecialGasLimit.Set { + e.FieldStart("special_gas_limit") + s.SpecialGasLimit.Encode(e) } } { - if s.ReturnEmulation.Set { - e.FieldStart("return_emulation") - s.ReturnEmulation.Encode(e) + if s.FlatGasLimit.Set { + e.FieldStart("flat_gas_limit") + s.FlatGasLimit.Encode(e) } } { - e.FieldStart("wallet_address") - e.Str(s.WalletAddress) + if s.FlatGasPrice.Set { + e.FieldStart("flat_gas_price") + s.FlatGasPrice.Encode(e) + } } { - e.FieldStart("wallet_public_key") - e.Str(s.WalletPublicKey) + e.FieldStart("gas_price") + e.Int64(s.GasPrice) } { - e.FieldStart("messages") - e.ArrStart() - for _, elem := range s.Messages { - elem.Encode(e) - } - e.ArrEnd() + 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 = [5]string{ - 0: "throw_error_if_not_enough_jettons", - 1: "return_emulation", - 2: "wallet_address", - 3: "wallet_public_key", - 4: "messages", -} - -// Decode decodes GaslessEstimateReq from json. -func (s *GaslessEstimateReq) Decode(d *jx.Decoder) error { +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 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 - s.setDefaults() + var requiredBitSet [2]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "throw_error_if_not_enough_jettons": + case "special_gas_limit": if err := func() error { - s.ThrowErrorIfNotEnoughJettons.Reset() - if err := s.ThrowErrorIfNotEnoughJettons.Decode(d); err != nil { + s.SpecialGasLimit.Reset() + if err := s.SpecialGasLimit.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"throw_error_if_not_enough_jettons\"") + return errors.Wrap(err, "decode field \"special_gas_limit\"") } - case "return_emulation": + case "flat_gas_limit": if err := func() error { - s.ReturnEmulation.Reset() - if err := s.ReturnEmulation.Decode(d); err != nil { + s.FlatGasLimit.Reset() + if err := s.FlatGasLimit.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"return_emulation\"") + return errors.Wrap(err, "decode field \"flat_gas_limit\"") } - case "wallet_address": - requiredBitSet[0] |= 1 << 2 + case "flat_gas_price": if err := func() error { - v, err := d.Str() - s.WalletAddress = string(v) - if err != nil { + s.FlatGasPrice.Reset() + if err := s.FlatGasPrice.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"wallet_address\"") + return errors.Wrap(err, "decode field \"flat_gas_price\"") } - case "wallet_public_key": + case "gas_price": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Str() - s.WalletPublicKey = string(v) + v, err := d.Int64() + s.GasPrice = 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_price\"") } - case "messages": + case "gas_limit": 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 { + v, err := d.Int64() + s.GasLimit = 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_limit\"") + } + case "gas_credit": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Int64() + s.GasCredit = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + 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{ - 0b00011100, + 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. @@ -18281,8 +18120,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) } @@ -18303,69 +18142,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. @@ -18377,8 +18246,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) } @@ -18399,86 +18268,96 @@ 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) { { - if s.WalletPublicKey.Set { - e.FieldStart("wallet_public_key") - s.WalletPublicKey.Encode(e) - } + 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": - if err := func() error { - s.WalletPublicKey.Reset() - if err := s.WalletPublicKey.Decode(d); err != nil { + case "relay_address": + 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 \"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 for i, mask := range [1]uint8{ - 0b00000010, + 0b00000011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -18490,8 +18369,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) } @@ -18512,81 +18391,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 *GaslessTx) Encode(e *jx.Encoder) { +func (s *GaslessConfigGasJettonsItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GaslessTx) encodeFields(e *jx.Encoder) { - { - e.FieldStart("protocol_name") - e.Str(s.ProtocolName) - } +func (s *GaslessConfigGasJettonsItem) encodeFields(e *jx.Encoder) { { - if s.External.Set { - e.FieldStart("external") - s.External.Encode(e) - } + e.FieldStart("master_id") + e.Str(s.MasterID) } } -var jsonFieldsNameOfGaslessTx = [2]string{ - 0: "protocol_name", - 1: "external", +var jsonFieldsNameOfGaslessConfigGasJettonsItem = [1]string{ + 0: "master_id", } -// Decode decodes GaslessTx from json. -func (s *GaslessTx) 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 GaslessTx 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 "protocol_name": + case "master_id": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.ProtocolName = string(v) + s.MasterID = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"protocol_name\"") - } - case "external": - if err := func() error { - s.External.Reset() - if err := s.External.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"external\"") + return errors.Wrap(err, "decode field \"master_id\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GaslessTx") + return errors.Wrap(err, "decode GaslessConfigGasJettonsItem") } // Validate required fields. var failures []validate.FieldError @@ -18603,8 +18465,8 @@ func (s *GaslessTx) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGaslessTx) { - name = jsonFieldsNameOfGaslessTx[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGaslessConfigGasJettonsItem) { + name = jsonFieldsNameOfGaslessConfigGasJettonsItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -18625,69 +18487,148 @@ func (s *GaslessTx) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GaslessTx) 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 *GaslessTx) 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 *GetAccountDiffOK) Encode(e *jx.Encoder) { +func (s *GaslessEstimateReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetAccountDiffOK) encodeFields(e *jx.Encoder) { +func (s *GaslessEstimateReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("balance_change") - e.Int64(s.BalanceChange) + 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 jsonFieldsNameOfGetAccountDiffOK = [1]string{ - 0: "balance_change", +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 GetAccountDiffOK from json. -func (s *GetAccountDiffOK) 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 GetAccountDiffOK 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 "balance_change": - requiredBitSet[0] |= 1 << 0 + case "throw_error_if_not_enough_jettons": if err := func() error { - v, err := d.Int64() - s.BalanceChange = int64(v) + 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.WalletAddress = 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 \"wallet_address\"") + } + 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 GetAccountDiffOK") + return errors.Wrap(err, "decode GaslessEstimateReq") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00011100, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -18699,8 +18640,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(jsonFieldsNameOfGaslessEstimateReq) { + name = jsonFieldsNameOfGaslessEstimateReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -18721,64 +18662,64 @@ func (s *GetAccountDiffOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetAccountDiffOK) 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 *GetAccountDiffOK) 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 *GetAccountInfoByStateInitReq) Encode(e *jx.Encoder) { +func (s *GaslessEstimateReqMessagesItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetAccountInfoByStateInitReq) encodeFields(e *jx.Encoder) { +func (s *GaslessEstimateReqMessagesItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("state_init") - e.Str(s.StateInit) + e.FieldStart("boc") + e.Str(s.Boc) } } -var jsonFieldsNameOfGetAccountInfoByStateInitReq = [1]string{ - 0: "state_init", +var jsonFieldsNameOfGaslessEstimateReqMessagesItem = [1]string{ + 0: "boc", } -// Decode decodes GetAccountInfoByStateInitReq from json. -func (s *GetAccountInfoByStateInitReq) 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 GetAccountInfoByStateInitReq 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 "state_init": + case "boc": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.StateInit = string(v) + s.Boc = 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 \"boc\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetAccountInfoByStateInitReq") + return errors.Wrap(err, "decode GaslessEstimateReqMessagesItem") } // Validate required fields. var failures []validate.FieldError @@ -18795,8 +18736,8 @@ func (s *GetAccountInfoByStateInitReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetAccountInfoByStateInitReq) { - name = jsonFieldsNameOfGetAccountInfoByStateInitReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGaslessEstimateReqMessagesItem) { + name = jsonFieldsNameOfGaslessEstimateReqMessagesItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -18817,69 +18758,86 @@ func (s *GetAccountInfoByStateInitReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetAccountInfoByStateInitReq) 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 *GetAccountInfoByStateInitReq) 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 *GetAccountPublicKeyOK) Encode(e *jx.Encoder) { +func (s *GaslessSendReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetAccountPublicKeyOK) encodeFields(e *jx.Encoder) { +func (s *GaslessSendReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("public_key") - e.Str(s.PublicKey) + if s.WalletPublicKey.Set { + e.FieldStart("wallet_public_key") + s.WalletPublicKey.Encode(e) + } + } + { + e.FieldStart("boc") + e.Str(s.Boc) } } -var jsonFieldsNameOfGetAccountPublicKeyOK = [1]string{ - 0: "public_key", +var jsonFieldsNameOfGaslessSendReq = [2]string{ + 0: "wallet_public_key", + 1: "boc", } -// Decode decodes GetAccountPublicKeyOK from json. -func (s *GetAccountPublicKeyOK) 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 GetAccountPublicKeyOK 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 "public_key": - requiredBitSet[0] |= 1 << 0 + case "wallet_public_key": + if err := func() error { + s.WalletPublicKey.Reset() + if err := s.WalletPublicKey.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet_public_key\"") + } + case "boc": + requiredBitSet[0] |= 1 << 1 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 GaslessSendReq") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000001, + 0b00000010, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -18891,8 +18849,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(jsonFieldsNameOfGaslessSendReq) { + name = jsonFieldsNameOfGaslessSendReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -18913,76 +18871,81 @@ func (s *GetAccountPublicKeyOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetAccountPublicKeyOK) 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 *GetAccountPublicKeyOK) 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 *GetAccountsReq) Encode(e *jx.Encoder) { +func (s *GaslessTx) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetAccountsReq) encodeFields(e *jx.Encoder) { +func (s *GaslessTx) encodeFields(e *jx.Encoder) { { - e.FieldStart("account_ids") - e.ArrStart() - for _, elem := range s.AccountIds { - e.Str(elem) + e.FieldStart("protocol_name") + e.Str(s.ProtocolName) + } + { + if s.External.Set { + e.FieldStart("external") + s.External.Encode(e) } - e.ArrEnd() } } -var jsonFieldsNameOfGetAccountsReq = [1]string{ - 0: "account_ids", +var jsonFieldsNameOfGaslessTx = [2]string{ + 0: "protocol_name", + 1: "external", } -// Decode decodes GetAccountsReq from json. -func (s *GetAccountsReq) 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 GetAccountsReq 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 "account_ids": + case "protocol_name": 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.ProtocolName = 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 \"protocol_name\"") + } + case "external": + if err := func() error { + s.External.Reset() + if err := s.External.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"external\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetAccountsReq") + return errors.Wrap(err, "decode GaslessTx") } // Validate required fields. var failures []validate.FieldError @@ -18999,8 +18962,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(jsonFieldsNameOfGaslessTx) { + name = jsonFieldsNameOfGaslessTx[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19021,101 +18984,69 @@ func (s *GetAccountsReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetAccountsReq) 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 *GetAccountsReq) 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 *GetAllRawShardsInfoOK) Encode(e *jx.Encoder) { +func (s *GetAccountDiffOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetAllRawShardsInfoOK) encodeFields(e *jx.Encoder) { - { - e.FieldStart("id") - s.ID.Encode(e) - } - { - e.FieldStart("proof") - e.Str(s.Proof) - } +func (s *GetAccountDiffOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("data") - e.Str(s.Data) + e.FieldStart("balance_change") + e.Int64(s.BalanceChange) } } -var jsonFieldsNameOfGetAllRawShardsInfoOK = [3]string{ - 0: "id", - 1: "proof", - 2: "data", +var jsonFieldsNameOfGetAccountDiffOK = [1]string{ + 0: "balance_change", } -// Decode decodes GetAllRawShardsInfoOK from json. -func (s *GetAllRawShardsInfoOK) 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 GetAllRawShardsInfoOK 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 "id": + case "balance_change": 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) - 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) + v, err := d.Int64() + s.BalanceChange = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"data\"") + return errors.Wrap(err, "decode field \"balance_change\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetAllRawShardsInfoOK") + return errors.Wrap(err, "decode GetAccountDiffOK") } // 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. @@ -19127,8 +19058,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(jsonFieldsNameOfGetAccountDiffOK) { + name = jsonFieldsNameOfGetAccountDiffOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19149,62 +19080,64 @@ func (s *GetAllRawShardsInfoOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetAllRawShardsInfoOK) 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 *GetAllRawShardsInfoOK) 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 *GetChartRatesOK) Encode(e *jx.Encoder) { +func (s *GetAccountInfoByStateInitReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetChartRatesOK) encodeFields(e *jx.Encoder) { +func (s *GetAccountInfoByStateInitReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("points") - s.Points.Encode(e) + e.FieldStart("state_init") + e.Str(s.StateInit) } } -var jsonFieldsNameOfGetChartRatesOK = [1]string{ - 0: "points", +var jsonFieldsNameOfGetAccountInfoByStateInitReq = [1]string{ + 0: "state_init", } -// Decode decodes GetChartRatesOK from json. -func (s *GetChartRatesOK) 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 GetChartRatesOK 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 "points": + case "state_init": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Points.Decode(d); err != nil { + v, err := d.Str() + s.StateInit = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"points\"") + return errors.Wrap(err, "decode field \"state_init\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetChartRatesOK") + return errors.Wrap(err, "decode GetAccountInfoByStateInitReq") } // Validate required fields. var failures []validate.FieldError @@ -19221,8 +19154,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(jsonFieldsNameOfGetAccountInfoByStateInitReq) { + name = jsonFieldsNameOfGetAccountInfoByStateInitReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19243,76 +19176,64 @@ func (s *GetChartRatesOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetChartRatesOK) 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 *GetChartRatesOK) 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 *GetJettonInfosByAddressesReq) Encode(e *jx.Encoder) { +func (s *GetAccountPublicKeyOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetJettonInfosByAddressesReq) encodeFields(e *jx.Encoder) { +func (s *GetAccountPublicKeyOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("account_ids") - e.ArrStart() - for _, elem := range s.AccountIds { - e.Str(elem) - } - e.ArrEnd() + e.FieldStart("public_key") + e.Str(s.PublicKey) } } -var jsonFieldsNameOfGetJettonInfosByAddressesReq = [1]string{ - 0: "account_ids", +var jsonFieldsNameOfGetAccountPublicKeyOK = [1]string{ + 0: "public_key", } -// Decode decodes GetJettonInfosByAddressesReq from json. -func (s *GetJettonInfosByAddressesReq) 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 GetJettonInfosByAddressesReq 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 "account_ids": + case "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.PublicKey = 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 \"public_key\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetJettonInfosByAddressesReq") + return errors.Wrap(err, "decode GetAccountPublicKeyOK") } // Validate required fields. var failures []validate.FieldError @@ -19329,8 +19250,8 @@ func (s *GetJettonInfosByAddressesReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetJettonInfosByAddressesReq) { - name = jsonFieldsNameOfGetJettonInfosByAddressesReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetAccountPublicKeyOK) { + name = jsonFieldsNameOfGetAccountPublicKeyOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19351,74 +19272,76 @@ func (s *GetJettonInfosByAddressesReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetJettonInfosByAddressesReq) 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 *GetJettonInfosByAddressesReq) 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 *GetMarketsRatesOK) Encode(e *jx.Encoder) { +func (s *GetAccountsReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetMarketsRatesOK) encodeFields(e *jx.Encoder) { +func (s *GetAccountsReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("markets") + e.FieldStart("account_ids") e.ArrStart() - for _, elem := range s.Markets { - elem.Encode(e) + for _, elem := range s.AccountIds { + e.Str(elem) } e.ArrEnd() } } -var jsonFieldsNameOfGetMarketsRatesOK = [1]string{ - 0: "markets", +var jsonFieldsNameOfGetAccountsReq = [1]string{ + 0: "account_ids", } -// Decode decodes GetMarketsRatesOK from json. -func (s *GetMarketsRatesOK) 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 GetMarketsRatesOK to nil") + return errors.New("invalid: unable to decode GetAccountsReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "markets": + case "account_ids": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Markets = make([]MarketTonRates, 0) + s.AccountIds = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem MarketTonRates - if err := elem.Decode(d); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } - s.Markets = append(s.Markets, elem) + s.AccountIds = append(s.AccountIds, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"markets\"") + return errors.Wrap(err, "decode field \"account_ids\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetMarketsRatesOK") + return errors.Wrap(err, "decode GetAccountsReq") } // Validate required fields. var failures []validate.FieldError @@ -19435,8 +19358,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(jsonFieldsNameOfGetAccountsReq) { + name = jsonFieldsNameOfGetAccountsReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19457,81 +19380,101 @@ func (s *GetMarketsRatesOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetMarketsRatesOK) 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 *GetMarketsRatesOK) 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 *GetNftCollectionItemsByAddressesReq) Encode(e *jx.Encoder) { +func (s *GetAllRawShardsInfoOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetNftCollectionItemsByAddressesReq) encodeFields(e *jx.Encoder) { +func (s *GetAllRawShardsInfoOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("account_ids") - e.ArrStart() - for _, elem := range s.AccountIds { - e.Str(elem) - } - e.ArrEnd() + e.FieldStart("id") + s.ID.Encode(e) + } + { + e.FieldStart("proof") + e.Str(s.Proof) + } + { + e.FieldStart("data") + e.Str(s.Data) } } -var jsonFieldsNameOfGetNftCollectionItemsByAddressesReq = [1]string{ - 0: "account_ids", +var jsonFieldsNameOfGetAllRawShardsInfoOK = [3]string{ + 0: "id", + 1: "proof", + 2: "data", } -// Decode decodes GetNftCollectionItemsByAddressesReq from json. -func (s *GetNftCollectionItemsByAddressesReq) 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 GetNftCollectionItemsByAddressesReq 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 "account_ids": + case "id": 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 { + if err := s.ID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"account_ids\"") + 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\"") + } + 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 GetNftCollectionItemsByAddressesReq") + return errors.Wrap(err, "decode GetAllRawShardsInfoOK") } // 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. @@ -19543,8 +19486,8 @@ func (s *GetNftCollectionItemsByAddressesReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetNftCollectionItemsByAddressesReq) { - name = jsonFieldsNameOfGetNftCollectionItemsByAddressesReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetAllRawShardsInfoOK) { + name = jsonFieldsNameOfGetAllRawShardsInfoOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19565,76 +19508,62 @@ func (s *GetNftCollectionItemsByAddressesReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetNftCollectionItemsByAddressesReq) 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 *GetNftCollectionItemsByAddressesReq) 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 *GetNftItemsByAddressesReq) Encode(e *jx.Encoder) { +func (s *GetChartRatesOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetNftItemsByAddressesReq) encodeFields(e *jx.Encoder) { +func (s *GetChartRatesOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("account_ids") - e.ArrStart() - for _, elem := range s.AccountIds { - e.Str(elem) - } - e.ArrEnd() + e.FieldStart("points") + s.Points.Encode(e) } } -var jsonFieldsNameOfGetNftItemsByAddressesReq = [1]string{ - 0: "account_ids", +var jsonFieldsNameOfGetChartRatesOK = [1]string{ + 0: "points", } -// Decode decodes GetNftItemsByAddressesReq from json. -func (s *GetNftItemsByAddressesReq) 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 GetNftItemsByAddressesReq 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 "account_ids": + case "points": 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 { + if err := s.Points.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"account_ids\"") + return errors.Wrap(err, "decode field \"points\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetNftItemsByAddressesReq") + return errors.Wrap(err, "decode GetChartRatesOK") } // Validate required fields. var failures []validate.FieldError @@ -19651,8 +19580,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(jsonFieldsNameOfGetChartRatesOK) { + name = jsonFieldsNameOfGetChartRatesOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19673,96 +19602,268 @@ func (s *GetNftItemsByAddressesReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetNftItemsByAddressesReq) 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 *GetNftItemsByAddressesReq) 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 *GetOutMsgQueueSizesOK) Encode(e *jx.Encoder) { +func (s *GetCocoonWorkersNotImplemented) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetOutMsgQueueSizesOK) encodeFields(e *jx.Encoder) { - { - e.FieldStart("ext_msg_queue_size_limit") - e.UInt32(s.ExtMsgQueueSizeLimit) +func (s *GetCocoonWorkersNotImplemented) encodeFields(e *jx.Encoder) { +} + +var jsonFieldsNameOfGetCocoonWorkersNotImplemented = [0]string{} + +// Decode decodes GetCocoonWorkersNotImplemented from json. +func (s *GetCocoonWorkersNotImplemented) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GetCocoonWorkersNotImplemented to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + default: + return d.Skip() + } + }); err != nil { + return errors.Wrap(err, "decode GetCocoonWorkersNotImplemented") } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *GetCocoonWorkersNotImplemented) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GetCocoonWorkersNotImplemented) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *GetCocoonWorkersUnauthorized) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *GetCocoonWorkersUnauthorized) encodeFields(e *jx.Encoder) { { - e.FieldStart("shards") - e.ArrStart() - for _, elem := range s.Shards { - elem.Encode(e) + if s.Error.Set { + e.FieldStart("error") + s.Error.Encode(e) } - e.ArrEnd() } } -var jsonFieldsNameOfGetOutMsgQueueSizesOK = [2]string{ - 0: "ext_msg_queue_size_limit", - 1: "shards", +var jsonFieldsNameOfGetCocoonWorkersUnauthorized = [1]string{ + 0: "error", } -// Decode decodes GetOutMsgQueueSizesOK from json. -func (s *GetOutMsgQueueSizesOK) Decode(d *jx.Decoder) error { +// Decode decodes GetCocoonWorkersUnauthorized from json. +func (s *GetCocoonWorkersUnauthorized) 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 GetCocoonWorkersUnauthorized 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": - requiredBitSet[0] |= 1 << 0 + case "error": if err := func() error { - v, err := d.UInt32() - s.ExtMsgQueueSizeLimit = uint32(v) - if err != nil { + s.Error.Reset() + if err := s.Error.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 \"error\"") } - case "shards": - 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) + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode GetCocoonWorkersUnauthorized") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *GetCocoonWorkersUnauthorized) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GetCocoonWorkersUnauthorized) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *GetCocoonWorkersUnauthorizedError) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *GetCocoonWorkersUnauthorizedError) encodeFields(e *jx.Encoder) { + { + if s.Message.Set { + e.FieldStart("message") + s.Message.Encode(e) + } + } + { + if s.Type.Set { + e.FieldStart("type") + s.Type.Encode(e) + } + } +} + +var jsonFieldsNameOfGetCocoonWorkersUnauthorizedError = [2]string{ + 0: "message", + 1: "type", +} + +// Decode decodes GetCocoonWorkersUnauthorizedError from json. +func (s *GetCocoonWorkersUnauthorizedError) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GetCocoonWorkersUnauthorizedError to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "message": + if err := func() error { + s.Message.Reset() + if err := s.Message.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"message\"") + } + case "type": + if err := func() error { + s.Type.Reset() + if err := s.Type.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"type\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode GetCocoonWorkersUnauthorizedError") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *GetCocoonWorkersUnauthorizedError) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GetCocoonWorkersUnauthorizedError) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *GetJettonInfosByAddressesReq) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *GetJettonInfosByAddressesReq) encodeFields(e *jx.Encoder) { + { + e.FieldStart("account_ids") + e.ArrStart() + for _, elem := range s.AccountIds { + e.Str(elem) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfGetJettonInfosByAddressesReq = [1]string{ + 0: "account_ids", +} + +// Decode decodes GetJettonInfosByAddressesReq from json. +func (s *GetJettonInfosByAddressesReq) Decode(d *jx.Decoder) error { + if s == 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 "account_ids": + 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 { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"shards\"") + return errors.Wrap(err, "decode field \"account_ids\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetOutMsgQueueSizesOK") + return errors.Wrap(err, "decode GetJettonInfosByAddressesReq") } // 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. @@ -19774,8 +19875,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(jsonFieldsNameOfGetJettonInfosByAddressesReq) { + name = jsonFieldsNameOfGetJettonInfosByAddressesReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19796,84 +19897,79 @@ func (s *GetOutMsgQueueSizesOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetOutMsgQueueSizesOK) 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 *GetOutMsgQueueSizesOK) 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 *GetOutMsgQueueSizesOKShardsItem) Encode(e *jx.Encoder) { +func (s *GetMarketsRatesOK) 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 *GetMarketsRatesOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("size") - e.UInt32(s.Size) + e.FieldStart("markets") + e.ArrStart() + for _, elem := range s.Markets { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfGetOutMsgQueueSizesOKShardsItem = [2]string{ - 0: "id", - 1: "size", +var jsonFieldsNameOfGetMarketsRatesOK = [1]string{ + 0: "markets", } -// Decode decodes GetOutMsgQueueSizesOKShardsItem from json. -func (s *GetOutMsgQueueSizesOKShardsItem) 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 GetOutMsgQueueSizesOKShardsItem 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 "size": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.UInt32() - s.Size = uint32(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 \"size\"") + return errors.Wrap(err, "decode field \"markets\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetOutMsgQueueSizesOKShardsItem") + return errors.Wrap(err, "decode GetMarketsRatesOK") } // 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. @@ -19885,8 +19981,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(jsonFieldsNameOfGetMarketsRatesOK) { + name = jsonFieldsNameOfGetMarketsRatesOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -19907,62 +20003,76 @@ func (s *GetOutMsgQueueSizesOKShardsItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetOutMsgQueueSizesOKShardsItem) 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 *GetOutMsgQueueSizesOKShardsItem) 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 *GetRatesOK) Encode(e *jx.Encoder) { +func (s *GetNftCollectionItemsByAddressesReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRatesOK) encodeFields(e *jx.Encoder) { +func (s *GetNftCollectionItemsByAddressesReq) 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 jsonFieldsNameOfGetNftCollectionItemsByAddressesReq = [1]string{ + 0: "account_ids", } -// Decode decodes GetRatesOK from json. -func (s *GetRatesOK) 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 GetRatesOK 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 "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 GetNftCollectionItemsByAddressesReq") } // Validate required fields. var failures []validate.FieldError @@ -19979,8 +20089,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(jsonFieldsNameOfGetNftCollectionItemsByAddressesReq) { + name = jsonFieldsNameOfGetNftCollectionItemsByAddressesReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20001,187 +20111,81 @@ func (s *GetRatesOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRatesOK) 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 *GetRatesOK) 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 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) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetRatesOKRates) 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 *GetNftItemsByAddressesReq) 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 *GetNftItemsByAddressesReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("state") - e.Str(s.State) + e.FieldStart("account_ids") + e.ArrStart() + for _, elem := range s.AccountIds { + e.Str(elem) + } + e.ArrEnd() } } -var jsonFieldsNameOfGetRawAccountStateOK = [5]string{ - 0: "id", - 1: "shardblk", - 2: "shard_proof", - 3: "proof", - 4: "state", +var jsonFieldsNameOfGetNftItemsByAddressesReq = [1]string{ + 0: "account_ids", } -// Decode decodes GetRawAccountStateOK from json. -func (s *GetRawAccountStateOK) 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 GetRawAccountStateOK 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 "id": + case "account_ids": 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.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 \"state\"") + return errors.Wrap(err, "decode field \"account_ids\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawAccountStateOK") + return errors.Wrap(err, "decode GetNftItemsByAddressesReq") } // 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. @@ -20193,8 +20197,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(jsonFieldsNameOfGetNftItemsByAddressesReq) { + name = jsonFieldsNameOfGetNftItemsByAddressesReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20215,126 +20219,96 @@ func (s *GetRawAccountStateOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawAccountStateOK) 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 *GetRawAccountStateOK) 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 *GetRawBlockProofOK) Encode(e *jx.Encoder) { +func (s *GetOutMsgQueueSizesOK) 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) - } - { - e.FieldStart("from") - s.From.Encode(e) - } +func (s *GetOutMsgQueueSizesOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("to") - s.To.Encode(e) + e.FieldStart("ext_msg_queue_size_limit") + e.UInt32(s.ExtMsgQueueSizeLimit) } { - e.FieldStart("steps") + e.FieldStart("shards") e.ArrStart() - for _, elem := range s.Steps { + for _, elem := range s.Shards { elem.Encode(e) } e.ArrEnd() } } -var jsonFieldsNameOfGetRawBlockProofOK = [4]string{ - 0: "complete", - 1: "from", - 2: "to", - 3: "steps", +var jsonFieldsNameOfGetOutMsgQueueSizesOK = [2]string{ + 0: "ext_msg_queue_size_limit", + 1: "shards", } -// Decode decodes GetRawBlockProofOK from json. -func (s *GetRawBlockProofOK) 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 GetRawBlockProofOK 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 "complete": + case "ext_msg_queue_size_limit": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Bool() - s.Complete = 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 \"complete\"") + 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 "steps": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - s.Steps = make([]GetRawBlockProofOKStepsItem, 0) + s.Shards = make([]GetOutMsgQueueSizesOKShardsItem, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem GetRawBlockProofOKStepsItem + var elem GetOutMsgQueueSizesOKShardsItem if err := elem.Decode(d); err != nil { return err } - s.Steps = append(s.Steps, elem) + s.Shards = append(s.Shards, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"steps\"") + return errors.Wrap(err, "decode field \"shards\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockProofOK") + return errors.Wrap(err, "decode GetOutMsgQueueSizesOK") } // 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. @@ -20346,8 +20320,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(jsonFieldsNameOfGetOutMsgQueueSizesOK) { + name = jsonFieldsNameOfGetOutMsgQueueSizesOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20368,77 +20342,79 @@ func (s *GetRawBlockProofOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockProofOK) 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 *GetRawBlockProofOK) 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 *GetRawBlockProofOKStepsItem) Encode(e *jx.Encoder) { +func (s *GetOutMsgQueueSizesOKShardsItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockProofOKStepsItem) encodeFields(e *jx.Encoder) { +func (s *GetOutMsgQueueSizesOKShardsItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("lite_server_block_link_back") - s.LiteServerBlockLinkBack.Encode(e) + e.FieldStart("id") + s.ID.Encode(e) } { - e.FieldStart("lite_server_block_link_forward") - s.LiteServerBlockLinkForward.Encode(e) + e.FieldStart("size") + e.UInt32(s.Size) } } -var jsonFieldsNameOfGetRawBlockProofOKStepsItem = [2]string{ - 0: "lite_server_block_link_back", - 1: "lite_server_block_link_forward", +var jsonFieldsNameOfGetOutMsgQueueSizesOKShardsItem = [2]string{ + 0: "id", + 1: "size", } -// Decode decodes GetRawBlockProofOKStepsItem from json. -func (s *GetRawBlockProofOKStepsItem) 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 GetRawBlockProofOKStepsItem 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 "lite_server_block_link_back": + case "id": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.LiteServerBlockLinkBack.Decode(d); err != nil { + if err := s.ID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"lite_server_block_link_back\"") + return errors.Wrap(err, "decode field \"id\"") } - case "lite_server_block_link_forward": + case "size": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.LiteServerBlockLinkForward.Decode(d); err != nil { + v, err := d.UInt32() + s.Size = uint32(v) + if 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 \"size\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockProofOKStepsItem") + return errors.Wrap(err, "decode GetOutMsgQueueSizesOKShardsItem") } // Validate required fields. var failures []validate.FieldError @@ -20455,8 +20431,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(jsonFieldsNameOfGetOutMsgQueueSizesOKShardsItem) { + name = jsonFieldsNameOfGetOutMsgQueueSizesOKShardsItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20477,150 +20453,67 @@ func (s *GetRawBlockProofOKStepsItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockProofOKStepsItem) 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 *GetRawBlockProofOKStepsItem) 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 *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) Encode(e *jx.Encoder) { +func (s *GetRatesOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) 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) - } - { - e.FieldStart("proof") - e.Str(s.Proof) - } +func (s *GetRatesOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("state_proof") - e.Str(s.StateProof) + e.FieldStart("rates") + s.Rates.Encode(e) } } -var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkBack = [6]string{ - 0: "to_key_block", - 1: "from", - 2: "to", - 3: "dest_proof", - 4: "proof", - 5: "state_proof", +var jsonFieldsNameOfGetRatesOK = [1]string{ + 0: "rates", } -// Decode decodes GetRawBlockProofOKStepsItemLiteServerBlockLinkBack from json. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) 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 GetRawBlockProofOKStepsItemLiteServerBlockLinkBack 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 "to_key_block": + case "rates": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Bool() - s.ToKeyBlock = bool(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"to_key_block\"") - } - 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 "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 { + if err := s.Rates.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"state_proof\"") + return errors.Wrap(err, "decode field \"rates\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkBack") + return errors.Wrap(err, "decode GetRatesOK") } // 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. @@ -20632,8 +20525,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(jsonFieldsNameOfGetRatesOK) { + name = jsonFieldsNameOfGetRatesOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20654,148 +20547,187 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) Decode(d *jx.Decode } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) 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 *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) 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 *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) Encode(e *jx.Encoder) { +func (s GetRatesOKRates) 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) +// 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) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GetRatesOKRates) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *GetRawAccountStateOK) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *GetRawAccountStateOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("from") - s.From.Encode(e) + e.FieldStart("id") + s.ID.Encode(e) } { - e.FieldStart("to") - s.To.Encode(e) + e.FieldStart("shardblk") + s.Shardblk.Encode(e) } { - e.FieldStart("dest_proof") - e.Str(s.DestProof) + e.FieldStart("shard_proof") + e.Str(s.ShardProof) } { - e.FieldStart("config_proof") - e.Str(s.ConfigProof) + e.FieldStart("proof") + e.Str(s.Proof) } { - e.FieldStart("signatures") - s.Signatures.Encode(e) + e.FieldStart("state") + e.Str(s.State) } } -var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForward = [6]string{ - 0: "to_key_block", - 1: "from", - 2: "to", - 3: "dest_proof", - 4: "config_proof", - 5: "signatures", -} - -// Decode decodes GetRawBlockProofOKStepsItemLiteServerBlockLinkForward from json. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) Decode(d *jx.Decoder) error { +var jsonFieldsNameOfGetRawAccountStateOK = [5]string{ + 0: "id", + 1: "shardblk", + 2: "shard_proof", + 3: "proof", + 4: "state", +} + +// Decode decodes GetRawAccountStateOK from json. +func (s *GetRawAccountStateOK) 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 GetRawAccountStateOK 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 "shardblk": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.From.Decode(d); err != nil { + if err := s.Shardblk.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"from\"") + return errors.Wrap(err, "decode field \"shardblk\"") } - case "to": + case "shard_proof": requiredBitSet[0] |= 1 << 2 if err := func() error { - if err := s.To.Decode(d); err != nil { + v, err := d.Str() + s.ShardProof = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"to\"") + return errors.Wrap(err, "decode field \"shard_proof\"") } - case "dest_proof": + case "proof": requiredBitSet[0] |= 1 << 3 if err := func() error { v, err := d.Str() - s.DestProof = string(v) + s.Proof = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"dest_proof\"") + return errors.Wrap(err, "decode field \"proof\"") } - case "config_proof": + case "state": requiredBitSet[0] |= 1 << 4 if err := func() error { v, err := d.Str() - s.ConfigProof = string(v) + s.State = string(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 \"state\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForward") + return errors.Wrap(err, "decode GetRawAccountStateOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00111111, + 0b00011111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -20807,8 +20739,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(jsonFieldsNameOfGetRawAccountStateOK) { + name = jsonFieldsNameOfGetRawAccountStateOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20829,113 +20761,126 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) Decode(d *jx.Dec } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) 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 *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) 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 *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) Encode(e *jx.Encoder) { +func (s *GetRawBlockProofOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) encodeFields(e *jx.Encoder) { +func (s *GetRawBlockProofOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("validator_set_hash") - e.Int64(s.ValidatorSetHash) + e.FieldStart("complete") + e.Bool(s.Complete) } { - e.FieldStart("catchain_seqno") - e.Int32(s.CatchainSeqno) + e.FieldStart("from") + s.From.Encode(e) } { - e.FieldStart("signatures") + e.FieldStart("to") + s.To.Encode(e) + } + { + e.FieldStart("steps") e.ArrStart() - for _, elem := range s.Signatures { + for _, elem := range s.Steps { elem.Encode(e) } e.ArrEnd() } } -var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures = [3]string{ - 0: "validator_set_hash", - 1: "catchain_seqno", - 2: "signatures", +var jsonFieldsNameOfGetRawBlockProofOK = [4]string{ + 0: "complete", + 1: "from", + 2: "to", + 3: "steps", } -// Decode decodes GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures from json. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) Decode(d *jx.Decoder) error { +// Decode decodes GetRawBlockProofOK from json. +func (s *GetRawBlockProofOK) 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 GetRawBlockProofOK 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 "complete": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.ValidatorSetHash = int64(v) + v, err := d.Bool() + s.Complete = bool(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"validator_set_hash\"") + return errors.Wrap(err, "decode field \"complete\"") } - case "catchain_seqno": + case "from": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int32() - s.CatchainSeqno = 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 \"catchain_seqno\"") + return errors.Wrap(err, "decode field \"from\"") } - case "signatures": + case "to": requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Signatures = make([]GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem, 0) + 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 GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem + var elem GetRawBlockProofOKStepsItem if err := elem.Decode(d); err != nil { return err } - s.Signatures = append(s.Signatures, elem) + s.Steps = append(s.Steps, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"signatures\"") + return errors.Wrap(err, "decode field \"steps\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures") + return errors.Wrap(err, "decode GetRawBlockProofOK") } // 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. @@ -20947,8 +20892,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(jsonFieldsNameOfGetRawBlockProofOK) { + name = jsonFieldsNameOfGetRawBlockProofOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -20969,81 +20914,77 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) Decode } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) 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 *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) 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 *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) Encode(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) encodeFields(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("node_id_short") - e.Str(s.NodeIDShort) + e.FieldStart("lite_server_block_link_back") + s.LiteServerBlockLinkBack.Encode(e) } { - e.FieldStart("signature") - e.Str(s.Signature) + e.FieldStart("lite_server_block_link_forward") + s.LiteServerBlockLinkForward.Encode(e) } } -var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem = [2]string{ - 0: "node_id_short", - 1: "signature", +var jsonFieldsNameOfGetRawBlockProofOKStepsItem = [2]string{ + 0: "lite_server_block_link_back", + 1: "lite_server_block_link_forward", } -// Decode decodes GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem from json. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) 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 GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem 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 "node_id_short": + case "lite_server_block_link_back": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.NodeIDShort = string(v) - if err != nil { + if err := s.LiteServerBlockLinkBack.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"node_id_short\"") + return errors.Wrap(err, "decode field \"lite_server_block_link_back\"") } - case "signature": + case "lite_server_block_link_forward": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.Signature = 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 \"signature\"") + return errors.Wrap(err, "decode field \"lite_server_block_link_forward\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem") + return errors.Wrap(err, "decode GetRawBlockProofOKStepsItem") } // Validate required fields. var failures []validate.FieldError @@ -21060,8 +21001,8 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignatur bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) { - name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetRawBlockProofOKStepsItem) { + name = jsonFieldsNameOfGetRawBlockProofOKStepsItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21082,101 +21023,150 @@ func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignatur } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) 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 *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) 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 *GetRawBlockchainBlockHeaderOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockchainBlockHeaderOK) encodeFields(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkBack) encodeFields(e *jx.Encoder) { { - e.FieldStart("id") - s.ID.Encode(e) + e.FieldStart("to_key_block") + e.Bool(s.ToKeyBlock) } { - e.FieldStart("mode") - e.Int32(s.Mode) + e.FieldStart("from") + s.From.Encode(e) } { - e.FieldStart("header_proof") - e.Str(s.HeaderProof) + 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) } } -var jsonFieldsNameOfGetRawBlockchainBlockHeaderOK = [3]string{ - 0: "id", - 1: "mode", - 2: "header_proof", +var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkBack = [6]string{ + 0: "to_key_block", + 1: "from", + 2: "to", + 3: "dest_proof", + 4: "proof", + 5: "state_proof", } -// Decode decodes GetRawBlockchainBlockHeaderOK from json. -func (s *GetRawBlockchainBlockHeaderOK) 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 GetRawBlockchainBlockHeaderOK 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 "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 "mode": + case "from": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int32() - s.Mode = 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 \"mode\"") + return errors.Wrap(err, "decode field \"from\"") } - case "header_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.HeaderProof = string(v) + s.DestProof = 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 \"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 { + 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 GetRawBlockchainBlockHeaderOK") + return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkBack") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b00111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -21188,8 +21178,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(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkBack) { + name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkBack[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21210,84 +21200,148 @@ func (s *GetRawBlockchainBlockHeaderOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockchainBlockHeaderOK) 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 *GetRawBlockchainBlockHeaderOK) 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 *GetRawBlockchainBlockOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForward) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawBlockchainBlockOK) 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("data") - e.Str(s.Data) + e.FieldStart("from") + s.From.Encode(e) + } + { + e.FieldStart("to") + s.To.Encode(e) + } + { + e.FieldStart("dest_proof") + e.Str(s.DestProof) + } + { + e.FieldStart("config_proof") + e.Str(s.ConfigProof) + } + { + e.FieldStart("signatures") + s.Signatures.Encode(e) } } -var jsonFieldsNameOfGetRawBlockchainBlockOK = [2]string{ - 0: "id", - 1: "data", +var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForward = [6]string{ + 0: "to_key_block", + 1: "from", + 2: "to", + 3: "dest_proof", + 4: "config_proof", + 5: "signatures", } -// Decode decodes GetRawBlockchainBlockOK from json. -func (s *GetRawBlockchainBlockOK) 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 GetRawBlockchainBlockOK 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 "data": + 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 "dest_proof": + requiredBitSet[0] |= 1 << 3 if err := func() error { v, err := d.Str() - s.Data = string(v) + s.DestProof = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"data\"") + 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) + 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\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockchainBlockOK") + return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForward") } // 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. @@ -21299,8 +21353,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(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForward) { + name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForward[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21321,118 +21375,113 @@ func (s *GetRawBlockchainBlockOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockchainBlockOK) 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 *GetRawBlockchainBlockOK) 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 *GetRawBlockchainBlockStateOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) 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) - } +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) encodeFields(e *jx.Encoder) { { - e.FieldStart("root_hash") - e.Str(s.RootHash) + e.FieldStart("validator_set_hash") + e.Int64(s.ValidatorSetHash) } { - e.FieldStart("file_hash") - e.Str(s.FileHash) + e.FieldStart("catchain_seqno") + e.Int32(s.CatchainSeqno) } { - e.FieldStart("data") - e.Str(s.Data) + e.FieldStart("signatures") + e.ArrStart() + for _, elem := range s.Signatures { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfGetRawBlockchainBlockStateOK = [4]string{ - 0: "id", - 1: "root_hash", - 2: "file_hash", - 3: "data", +var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures = [3]string{ + 0: "validator_set_hash", + 1: "catchain_seqno", + 2: "signatures", } -// Decode decodes GetRawBlockchainBlockStateOK from json. -func (s *GetRawBlockchainBlockStateOK) 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 GetRawBlockchainBlockStateOK 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 "id": + case "validator_set_hash": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.ID.Decode(d); err != nil { + v, err := d.Int64() + s.ValidatorSetHash = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"id\"") + return errors.Wrap(err, "decode field \"validator_set_hash\"") } - case "root_hash": + case "catchain_seqno": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.RootHash = string(v) + v, err := d.Int32() + s.CatchainSeqno = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"root_hash\"") + return errors.Wrap(err, "decode field \"catchain_seqno\"") } - case "file_hash": + case "signatures": 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 { + 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 \"data\"") + return errors.Wrap(err, "decode field \"signatures\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawBlockchainBlockStateOK") + return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures") } // 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. @@ -21444,8 +21493,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(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures) { + name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignatures[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21466,118 +21515,86 @@ func (s *GetRawBlockchainBlockStateOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawBlockchainBlockStateOK) 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 *GetRawBlockchainBlockStateOK) 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 *GetRawConfigOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawConfigOK) encodeFields(e *jx.Encoder) { - { - e.FieldStart("mode") - e.Int32(s.Mode) - } - { - e.FieldStart("id") - s.ID.Encode(e) - } +func (s *GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("state_proof") - e.Str(s.StateProof) + e.FieldStart("node_id_short") + e.Str(s.NodeIDShort) } { - e.FieldStart("config_proof") - e.Str(s.ConfigProof) + e.FieldStart("signature") + e.Str(s.Signature) } } -var jsonFieldsNameOfGetRawConfigOK = [4]string{ - 0: "mode", - 1: "id", - 2: "state_proof", - 3: "config_proof", +var jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem = [2]string{ + 0: "node_id_short", + 1: "signature", } -// Decode decodes GetRawConfigOK from json. -func (s *GetRawConfigOK) 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 GetRawConfigOK 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) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"mode\"") - } - case "id": - requiredBitSet[0] |= 1 << 1 - 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 "state_proof": - requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.StateProof = string(v) + s.NodeIDShort = 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 \"node_id_short\"") } - case "config_proof": - requiredBitSet[0] |= 1 << 3 + case "signature": + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.ConfigProof = string(v) + s.Signature = 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 \"signature\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawConfigOK") + return errors.Wrap(err, "decode GetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem") } // 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. @@ -21589,8 +21606,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(jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem) { + name = jsonFieldsNameOfGetRawBlockProofOKStepsItemLiteServerBlockLinkForwardSignaturesSignaturesItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21611,65 +21628,51 @@ func (s *GetRawConfigOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawConfigOK) 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 *GetRawConfigOK) 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 *GetRawListBlockTransactionsOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockchainBlockHeaderOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawListBlockTransactionsOK) encodeFields(e *jx.Encoder) { +func (s *GetRawBlockchainBlockHeaderOK) encodeFields(e *jx.Encoder) { { 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("mode") + e.Int32(s.Mode) } { - e.FieldStart("proof") - e.Str(s.Proof) + e.FieldStart("header_proof") + e.Str(s.HeaderProof) } } -var jsonFieldsNameOfGetRawListBlockTransactionsOK = [5]string{ +var jsonFieldsNameOfGetRawBlockchainBlockHeaderOK = [3]string{ 0: "id", - 1: "req_count", - 2: "incomplete", - 3: "ids", - 4: "proof", + 1: "mode", + 2: "header_proof", } -// Decode decodes GetRawListBlockTransactionsOK from json. -func (s *GetRawListBlockTransactionsOK) 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 GetRawListBlockTransactionsOK to nil") + return errors.New("invalid: unable to decode GetRawBlockchainBlockHeaderOK to nil") } var requiredBitSet [1]uint8 @@ -21685,71 +21688,41 @@ func (s *GetRawListBlockTransactionsOK) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"id\"") } - case "req_count": + case "mode": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Int32() - s.ReqCount = int32(v) + s.Mode = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"req_count\"") + return errors.Wrap(err, "decode field \"mode\"") } - case "incomplete": + case "header_proof": 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) + s.HeaderProof = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"proof\"") + return errors.Wrap(err, "decode field \"header_proof\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawListBlockTransactionsOK") + return errors.Wrap(err, "decode GetRawBlockchainBlockHeaderOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00011111, + 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -21761,8 +21734,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(jsonFieldsNameOfGetRawBlockchainBlockHeaderOK) { + name = jsonFieldsNameOfGetRawBlockchainBlockHeaderOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21783,120 +21756,84 @@ func (s *GetRawListBlockTransactionsOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawListBlockTransactionsOK) 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 *GetRawListBlockTransactionsOK) 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 *GetRawListBlockTransactionsOKIdsItem) Encode(e *jx.Encoder) { +func (s *GetRawBlockchainBlockOK) 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) - } - { - if s.Account.Set { - e.FieldStart("account") - s.Account.Encode(e) - } - } +func (s *GetRawBlockchainBlockOK) encodeFields(e *jx.Encoder) { { - if s.Lt.Set { - e.FieldStart("lt") - s.Lt.Encode(e) - } + e.FieldStart("id") + s.ID.Encode(e) } { - if s.Hash.Set { - e.FieldStart("hash") - s.Hash.Encode(e) - } + e.FieldStart("data") + e.Str(s.Data) } } -var jsonFieldsNameOfGetRawListBlockTransactionsOKIdsItem = [4]string{ - 0: "mode", - 1: "account", - 2: "lt", - 3: "hash", +var jsonFieldsNameOfGetRawBlockchainBlockOK = [2]string{ + 0: "id", + 1: "data", } -// Decode decodes GetRawListBlockTransactionsOKIdsItem from json. -func (s *GetRawListBlockTransactionsOKIdsItem) 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 GetRawListBlockTransactionsOKIdsItem 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 "mode": + case "id": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int32() - s.Mode = int32(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 { + if err := s.ID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"account\"") + return errors.Wrap(err, "decode field \"id\"") } - case "lt": + case "data": + requiredBitSet[0] |= 1 << 1 if err := func() error { - s.Lt.Reset() - if err := s.Lt.Decode(d); 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 \"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\"") + return errors.Wrap(err, "decode field \"data\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawListBlockTransactionsOKIdsItem") + return errors.Wrap(err, "decode GetRawBlockchainBlockOK") } // 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. @@ -21908,8 +21845,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(jsonFieldsNameOfGetRawBlockchainBlockOK) { + name = jsonFieldsNameOfGetRawBlockchainBlockOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -21930,184 +21867,118 @@ func (s *GetRawListBlockTransactionsOKIdsItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawListBlockTransactionsOKIdsItem) 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 *GetRawListBlockTransactionsOKIdsItem) 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 *GetRawMasterchainInfoExtOK) Encode(e *jx.Encoder) { +func (s *GetRawBlockchainBlockStateOK) 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) - } - { - e.FieldStart("capabilities") - e.Int64(s.Capabilities) - } - { - e.FieldStart("last") - s.Last.Encode(e) - } +func (s *GetRawBlockchainBlockStateOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("last_utime") - e.Int32(s.LastUtime) + e.FieldStart("id") + s.ID.Encode(e) } { - e.FieldStart("now") - e.Int32(s.Now) + e.FieldStart("root_hash") + e.Str(s.RootHash) } { - e.FieldStart("state_root_hash") - e.Str(s.StateRootHash) + e.FieldStart("file_hash") + e.Str(s.FileHash) } { - e.FieldStart("init") - s.Init.Encode(e) + e.FieldStart("data") + e.Str(s.Data) } } -var jsonFieldsNameOfGetRawMasterchainInfoExtOK = [8]string{ - 0: "mode", - 1: "version", - 2: "capabilities", - 3: "last", - 4: "last_utime", - 5: "now", - 6: "state_root_hash", - 7: "init", +var jsonFieldsNameOfGetRawBlockchainBlockStateOK = [4]string{ + 0: "id", + 1: "root_hash", + 2: "file_hash", + 3: "data", } -// Decode decodes GetRawMasterchainInfoExtOK from json. -func (s *GetRawMasterchainInfoExtOK) 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 GetRawMasterchainInfoExtOK to nil") + return errors.New("invalid: unable to decode GetRawBlockchainBlockStateOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "mode": + case "id": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int32() - s.Mode = int32(v) - if err != nil { + if err := s.ID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"mode\"") + return errors.Wrap(err, "decode field \"id\"") } - case "version": + case "root_hash": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int32() - s.Version = int32(v) + v, err := d.Str() + s.RootHash = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"version\"") + return errors.Wrap(err, "decode field \"root_hash\"") } - case "capabilities": + case "file_hash": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Int64() - s.Capabilities = int64(v) + v, err := d.Str() + s.FileHash = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"capabilities\"") + return errors.Wrap(err, "decode field \"file_hash\"") } - case "last": + case "data": 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.Data = 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 \"data\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawMasterchainInfoExtOK") + return errors.Wrap(err, "decode GetRawBlockchainBlockStateOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b11111111, + 0b00001111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -22119,8 +21990,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(jsonFieldsNameOfGetRawBlockchainBlockStateOK) { + name = jsonFieldsNameOfGetRawBlockchainBlockStateOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -22141,99 +22012,118 @@ func (s *GetRawMasterchainInfoExtOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawMasterchainInfoExtOK) 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 *GetRawMasterchainInfoExtOK) 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 *GetRawMasterchainInfoOK) Encode(e *jx.Encoder) { +func (s *GetRawConfigOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawMasterchainInfoOK) encodeFields(e *jx.Encoder) { +func (s *GetRawConfigOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("last") - s.Last.Encode(e) + e.FieldStart("mode") + e.Int32(s.Mode) } { - e.FieldStart("state_root_hash") - e.Str(s.StateRootHash) + e.FieldStart("id") + s.ID.Encode(e) } { - e.FieldStart("init") - s.Init.Encode(e) + e.FieldStart("state_proof") + e.Str(s.StateProof) + } + { + e.FieldStart("config_proof") + e.Str(s.ConfigProof) } } -var jsonFieldsNameOfGetRawMasterchainInfoOK = [3]string{ - 0: "last", - 1: "state_root_hash", - 2: "init", +var jsonFieldsNameOfGetRawConfigOK = [4]string{ + 0: "mode", + 1: "id", + 2: "state_proof", + 3: "config_proof", } -// Decode decodes GetRawMasterchainInfoOK from json. -func (s *GetRawMasterchainInfoOK) 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 GetRawMasterchainInfoOK 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 "last": + case "mode": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Last.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 \"last\"") + return errors.Wrap(err, "decode field \"mode\"") } - case "state_root_hash": + case "id": requiredBitSet[0] |= 1 << 1 + 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 "state_proof": + requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.StateRootHash = string(v) + s.StateProof = string(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 \"state_proof\"") } - case "init": - requiredBitSet[0] |= 1 << 2 + case "config_proof": + requiredBitSet[0] |= 1 << 3 if err := func() error { - if err := s.Init.Decode(d); err != nil { + v, err := d.Str() + s.ConfigProof = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"init\"") + return errors.Wrap(err, "decode field \"config_proof\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawMasterchainInfoOK") + return errors.Wrap(err, "decode GetRawConfigOK") } // 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. @@ -22245,8 +22135,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(jsonFieldsNameOfGetRawConfigOK) { + name = jsonFieldsNameOfGetRawConfigOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -22267,94 +22157,145 @@ func (s *GetRawMasterchainInfoOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawMasterchainInfoOK) 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 *GetRawMasterchainInfoOK) 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 *GetRawShardBlockProofOK) Encode(e *jx.Encoder) { +func (s *GetRawListBlockTransactionsOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawShardBlockProofOK) encodeFields(e *jx.Encoder) { +func (s *GetRawListBlockTransactionsOK) 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("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 jsonFieldsNameOfGetRawShardBlockProofOK = [2]string{ - 0: "masterchain_id", - 1: "links", +var jsonFieldsNameOfGetRawListBlockTransactionsOK = [5]string{ + 0: "id", + 1: "req_count", + 2: "incomplete", + 3: "ids", + 4: "proof", } -// Decode decodes GetRawShardBlockProofOK from json. -func (s *GetRawShardBlockProofOK) 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 GetRawShardBlockProofOK 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 "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 "req_count": requiredBitSet[0] |= 1 << 1 if err := func() error { - s.Links = make([]GetRawShardBlockProofOKLinksItem, 0) + v, err := d.Int32() + s.ReqCount = int32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + 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 GetRawShardBlockProofOKLinksItem + var elem GetRawListBlockTransactionsOKIdsItem if err := elem.Decode(d); err != nil { return err } - s.Links = append(s.Links, elem) + s.Ids = append(s.Ids, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"links\"") + 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 GetRawShardBlockProofOK") + return errors.Wrap(err, "decode GetRawListBlockTransactionsOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000011, + 0b00011111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -22366,8 +22307,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(jsonFieldsNameOfGetRawListBlockTransactionsOK) { + name = jsonFieldsNameOfGetRawListBlockTransactionsOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -22388,84 +22329,120 @@ func (s *GetRawShardBlockProofOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawShardBlockProofOK) 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 *GetRawShardBlockProofOK) 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 *GetRawShardBlockProofOKLinksItem) Encode(e *jx.Encoder) { +func (s *GetRawListBlockTransactionsOKIdsItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawShardBlockProofOKLinksItem) encodeFields(e *jx.Encoder) { +func (s *GetRawListBlockTransactionsOKIdsItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("id") - s.ID.Encode(e) + e.FieldStart("mode") + e.Int32(s.Mode) } { - e.FieldStart("proof") - e.Str(s.Proof) + if s.Account.Set { + e.FieldStart("account") + s.Account.Encode(e) + } + } + { + if s.Lt.Set { + e.FieldStart("lt") + s.Lt.Encode(e) + } + } + { + if s.Hash.Set { + e.FieldStart("hash") + s.Hash.Encode(e) + } } } -var jsonFieldsNameOfGetRawShardBlockProofOKLinksItem = [2]string{ - 0: "id", - 1: "proof", +var jsonFieldsNameOfGetRawListBlockTransactionsOKIdsItem = [4]string{ + 0: "mode", + 1: "account", + 2: "lt", + 3: "hash", } -// Decode decodes GetRawShardBlockProofOKLinksItem from json. -func (s *GetRawShardBlockProofOKLinksItem) 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 GetRawShardBlockProofOKLinksItem 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 "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 "proof": - requiredBitSet[0] |= 1 << 1 + case "account": if err := func() error { - v, err := d.Str() - s.Proof = 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 \"proof\"") + 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 GetRawShardBlockProofOKLinksItem") + 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. @@ -22477,8 +22454,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(jsonFieldsNameOfGetRawListBlockTransactionsOKIdsItem) { + name = jsonFieldsNameOfGetRawListBlockTransactionsOKIdsItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -22499,116 +22476,184 @@ func (s *GetRawShardBlockProofOKLinksItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawShardBlockProofOKLinksItem) 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 *GetRawShardBlockProofOKLinksItem) 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 *GetRawShardInfoOK) Encode(e *jx.Encoder) { +func (s *GetRawMasterchainInfoExtOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawShardInfoOK) encodeFields(e *jx.Encoder) { +func (s *GetRawMasterchainInfoExtOK) 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("version") + e.Int32(s.Version) } { - e.FieldStart("shard_proof") - e.Str(s.ShardProof) + e.FieldStart("capabilities") + e.Int64(s.Capabilities) } { - e.FieldStart("shard_descr") - e.Str(s.ShardDescr) + 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 jsonFieldsNameOfGetRawShardInfoOK = [4]string{ - 0: "id", - 1: "shardblk", - 2: "shard_proof", - 3: "shard_descr", +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 GetRawShardInfoOK from json. -func (s *GetRawShardInfoOK) 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 GetRawShardInfoOK 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 "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 "version": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Shardblk.Decode(d); err != nil { - return err - } + v, err := d.Int32() + s.Version = int32(v) + if err != nil { + return err + } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"shardblk\"") + return errors.Wrap(err, "decode field \"version\"") } - case "shard_proof": + case "capabilities": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Str() - s.ShardProof = string(v) + v, err := d.Int64() + s.Capabilities = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"shard_proof\"") + return errors.Wrap(err, "decode field \"capabilities\"") } - case "shard_descr": + 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.ShardDescr = string(v) + s.StateRootHash = 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 \"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 GetRawShardInfoOK") + return errors.Wrap(err, "decode GetRawMasterchainInfoExtOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001111, + 0b11111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -22620,8 +22665,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(jsonFieldsNameOfGetRawMasterchainInfoExtOK) { + name = jsonFieldsNameOfGetRawMasterchainInfoExtOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -22642,69 +22687,99 @@ func (s *GetRawShardInfoOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawShardInfoOK) 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 *GetRawShardInfoOK) 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 *GetRawTimeOK) Encode(e *jx.Encoder) { +func (s *GetRawMasterchainInfoOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawTimeOK) encodeFields(e *jx.Encoder) { +func (s *GetRawMasterchainInfoOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("time") - e.Int32(s.Time) + e.FieldStart("last") + s.Last.Encode(e) + } + { + e.FieldStart("state_root_hash") + e.Str(s.StateRootHash) + } + { + e.FieldStart("init") + s.Init.Encode(e) } } -var jsonFieldsNameOfGetRawTimeOK = [1]string{ - 0: "time", +var jsonFieldsNameOfGetRawMasterchainInfoOK = [3]string{ + 0: "last", + 1: "state_root_hash", + 2: "init", } -// Decode decodes GetRawTimeOK from json. -func (s *GetRawTimeOK) 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 GetRawTimeOK 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 "time": + case "last": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int32() - s.Time = int32(v) + if err := s.Last.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"last\"") + } + case "state_root_hash": + requiredBitSet[0] |= 1 << 1 + 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 \"time\"") + 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 GetRawTimeOK") + return errors.Wrap(err, "decode GetRawMasterchainInfoOK") } // 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. @@ -22716,8 +22791,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(jsonFieldsNameOfGetRawMasterchainInfoOK) { + name = jsonFieldsNameOfGetRawMasterchainInfoOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -22738,91 +22813,89 @@ func (s *GetRawTimeOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawTimeOK) 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 *GetRawTimeOK) 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 *GetRawTransactionsOK) Encode(e *jx.Encoder) { +func (s *GetRawShardBlockProofOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetRawTransactionsOK) encodeFields(e *jx.Encoder) { +func (s *GetRawShardBlockProofOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("ids") + e.FieldStart("masterchain_id") + s.MasterchainID.Encode(e) + } + { + e.FieldStart("links") e.ArrStart() - for _, elem := range s.Ids { + for _, elem := range s.Links { elem.Encode(e) } e.ArrEnd() } - { - e.FieldStart("transactions") - e.Str(s.Transactions) - } } -var jsonFieldsNameOfGetRawTransactionsOK = [2]string{ - 0: "ids", - 1: "transactions", +var jsonFieldsNameOfGetRawShardBlockProofOK = [2]string{ + 0: "masterchain_id", + 1: "links", } -// Decode decodes GetRawTransactionsOK from json. -func (s *GetRawTransactionsOK) 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 GetRawTransactionsOK 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 "ids": + case "masterchain_id": 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 { + if err := s.MasterchainID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ids\"") + return errors.Wrap(err, "decode field \"masterchain_id\"") } - case "transactions": + case "links": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.Transactions = string(v) - if 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 \"transactions\"") + return errors.Wrap(err, "decode field \"links\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetRawTransactionsOK") + return errors.Wrap(err, "decode GetRawShardBlockProofOK") } // Validate required fields. var failures []validate.FieldError @@ -22839,8 +22912,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(jsonFieldsNameOfGetRawShardBlockProofOK) { + name = jsonFieldsNameOfGetRawShardBlockProofOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -22861,79 +22934,84 @@ func (s *GetRawTransactionsOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetRawTransactionsOK) 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 *GetRawTransactionsOK) 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 *GetStakingPoolHistoryOK) Encode(e *jx.Encoder) { +func (s *GetRawShardBlockProofOKLinksItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetStakingPoolHistoryOK) encodeFields(e *jx.Encoder) { +func (s *GetRawShardBlockProofOKLinksItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("apy") - e.ArrStart() - for _, elem := range s.Apy { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("id") + s.ID.Encode(e) + } + { + e.FieldStart("proof") + e.Str(s.Proof) } } -var jsonFieldsNameOfGetStakingPoolHistoryOK = [1]string{ - 0: "apy", +var jsonFieldsNameOfGetRawShardBlockProofOKLinksItem = [2]string{ + 0: "id", + 1: "proof", } -// Decode decodes GetStakingPoolHistoryOK from json. -func (s *GetStakingPoolHistoryOK) 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 GetStakingPoolHistoryOK 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 "apy": + case "id": 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 { + if err := s.ID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"apy\"") + return errors.Wrap(err, "decode field \"id\"") } - default: - return d.Skip() + 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 GetStakingPoolHistoryOK") + 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. @@ -22945,8 +23023,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(jsonFieldsNameOfGetRawShardBlockProofOKLinksItem) { + name = jsonFieldsNameOfGetRawShardBlockProofOKLinksItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -22967,82 +23045,116 @@ func (s *GetStakingPoolHistoryOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetStakingPoolHistoryOK) 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 *GetStakingPoolHistoryOK) 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 *GetStakingPoolInfoOK) Encode(e *jx.Encoder) { +func (s *GetRawShardInfoOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetStakingPoolInfoOK) encodeFields(e *jx.Encoder) { +func (s *GetRawShardInfoOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("implementation") - s.Implementation.Encode(e) + e.FieldStart("id") + s.ID.Encode(e) } { - e.FieldStart("pool") - s.Pool.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 jsonFieldsNameOfGetStakingPoolInfoOK = [2]string{ - 0: "implementation", - 1: "pool", +var jsonFieldsNameOfGetRawShardInfoOK = [4]string{ + 0: "id", + 1: "shardblk", + 2: "shard_proof", + 3: "shard_descr", } -// Decode decodes GetStakingPoolInfoOK from json. -func (s *GetStakingPoolInfoOK) 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 GetStakingPoolInfoOK 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 "implementation": + case "id": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Implementation.Decode(d); err != nil { + if err := s.ID.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"implementation\"") + return errors.Wrap(err, "decode field \"id\"") } - case "pool": + case "shardblk": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Pool.Decode(d); err != nil { + if err := s.Shardblk.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"pool\"") + 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 "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 GetStakingPoolInfoOK") + return errors.Wrap(err, "decode GetRawShardInfoOK") } // 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. @@ -23054,8 +23166,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(jsonFieldsNameOfGetRawShardInfoOK) { + name = jsonFieldsNameOfGetRawShardInfoOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -23076,94 +23188,69 @@ func (s *GetStakingPoolInfoOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetStakingPoolInfoOK) 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 *GetStakingPoolInfoOK) 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 *GetStakingPoolsOK) Encode(e *jx.Encoder) { +func (s *GetRawTimeOK) 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() - } +func (s *GetRawTimeOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("implementations") - s.Implementations.Encode(e) + e.FieldStart("time") + e.Int32(s.Time) } } -var jsonFieldsNameOfGetStakingPoolsOK = [2]string{ - 0: "pools", - 1: "implementations", +var jsonFieldsNameOfGetRawTimeOK = [1]string{ + 0: "time", } -// Decode decodes GetStakingPoolsOK from json. -func (s *GetStakingPoolsOK) 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 GetStakingPoolsOK 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 "pools": + case "time": 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 { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"pools\"") - } - case "implementations": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - if err := s.Implementations.Decode(d); err != nil { + v, err := d.Int32() + s.Time = int32(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"implementations\"") + return errors.Wrap(err, "decode field \"time\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetStakingPoolsOK") + return errors.Wrap(err, "decode GetRawTimeOK") } // 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. @@ -23175,8 +23262,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(jsonFieldsNameOfGetRawTimeOK) { + name = jsonFieldsNameOfGetRawTimeOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -23197,133 +23284,96 @@ 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 *GetRawTimeOK) 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 *GetRawTimeOK) 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 *GetRawTransactionsOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetStorageProvidersOK) encodeFields(e *jx.Encoder) { +func (s *GetRawTransactionsOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("providers") + e.FieldStart("ids") e.ArrStart() - for _, elem := range s.Providers { + for _, elem := range s.Ids { elem.Encode(e) } e.ArrEnd() } + { + e.FieldStart("transactions") + e.Str(s.Transactions) + } } -var jsonFieldsNameOfGetStorageProvidersOK = [1]string{ - 0: "providers", +var jsonFieldsNameOfGetRawTransactionsOK = [2]string{ + 0: "ids", + 1: "transactions", } -// Decode decodes GetStorageProvidersOK from json. -func (s *GetStorageProvidersOK) 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 GetStorageProvidersOK 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 "providers": + case "ids": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Providers = make([]StorageProvider, 0) + s.Ids = make([]BlockRaw, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem StorageProvider + var elem BlockRaw if err := elem.Decode(d); err != nil { return err } - s.Providers = append(s.Providers, elem) + s.Ids = append(s.Ids, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"providers\"") + return errors.Wrap(err, "decode field \"ids\"") + } + case "transactions": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.Transactions = string(v) + if 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 GetStorageProvidersOK") + return errors.Wrap(err, "decode GetRawTransactionsOK") } // 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. @@ -23335,8 +23385,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(jsonFieldsNameOfGetRawTransactionsOK) { + name = jsonFieldsNameOfGetRawTransactionsOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -23357,64 +23407,74 @@ func (s *GetStorageProvidersOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetStorageProvidersOK) 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 *GetStorageProvidersOK) 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 *GetTonConnectPayloadOK) Encode(e *jx.Encoder) { +func (s *GetStakingPoolHistoryOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetTonConnectPayloadOK) encodeFields(e *jx.Encoder) { +func (s *GetStakingPoolHistoryOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("payload") - e.Str(s.Payload) + e.FieldStart("apy") + e.ArrStart() + for _, elem := range s.Apy { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfGetTonConnectPayloadOK = [1]string{ - 0: "payload", +var jsonFieldsNameOfGetStakingPoolHistoryOK = [1]string{ + 0: "apy", } -// Decode decodes GetTonConnectPayloadOK from json. -func (s *GetTonConnectPayloadOK) 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 GetTonConnectPayloadOK 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 "payload": + case "apy": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Payload = 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 \"payload\"") + return errors.Wrap(err, "decode field \"apy\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetTonConnectPayloadOK") + return errors.Wrap(err, "decode GetStakingPoolHistoryOK") } // Validate required fields. var failures []validate.FieldError @@ -23431,8 +23491,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(jsonFieldsNameOfGetStakingPoolHistoryOK) { + name = jsonFieldsNameOfGetStakingPoolHistoryOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -23453,81 +23513,82 @@ func (s *GetTonConnectPayloadOK) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetTonConnectPayloadOK) 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 *GetTonConnectPayloadOK) 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 *GetWalletsByPublicKeyBulkReq) Encode(e *jx.Encoder) { +func (s *GetStakingPoolInfoOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *GetWalletsByPublicKeyBulkReq) encodeFields(e *jx.Encoder) { +func (s *GetStakingPoolInfoOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("public_keys") - e.ArrStart() - for _, elem := range s.PublicKeys { - e.Str(elem) - } - e.ArrEnd() + e.FieldStart("implementation") + s.Implementation.Encode(e) + } + { + e.FieldStart("pool") + s.Pool.Encode(e) } } -var jsonFieldsNameOfGetWalletsByPublicKeyBulkReq = [1]string{ - 0: "public_keys", +var jsonFieldsNameOfGetStakingPoolInfoOK = [2]string{ + 0: "implementation", + 1: "pool", } -// Decode decodes GetWalletsByPublicKeyBulkReq from json. -func (s *GetWalletsByPublicKeyBulkReq) 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 GetWalletsByPublicKeyBulkReq 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 "public_keys": + case "implementation": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.PublicKeys = 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.PublicKeys = append(s.PublicKeys, 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 \"public_keys\"") + return errors.Wrap(err, "decode field \"implementation\"") + } + case "pool": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + if err := s.Pool.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"pool\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode GetWalletsByPublicKeyBulkReq") + return errors.Wrap(err, "decode GetStakingPoolInfoOK") } // 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. @@ -23539,8 +23600,8 @@ func (s *GetWalletsByPublicKeyBulkReq) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfGetWalletsByPublicKeyBulkReq) { - name = jsonFieldsNameOfGetWalletsByPublicKeyBulkReq[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetStakingPoolInfoOK) { + name = jsonFieldsNameOfGetStakingPoolInfoOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -23561,81 +23622,89 @@ func (s *GetWalletsByPublicKeyBulkReq) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *GetWalletsByPublicKeyBulkReq) MarshalJSON() ([]byte, error) { +func (s *GetStakingPoolInfoOK) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *GetWalletsByPublicKeyBulkReq) UnmarshalJSON(data []byte) error { +func (s *GetStakingPoolInfoOK) 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 *GetStakingPoolsOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *ImagePreview) encodeFields(e *jx.Encoder) { +func (s *GetStakingPoolsOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("resolution") - e.Str(s.Resolution) + e.FieldStart("pools") + e.ArrStart() + for _, elem := range s.Pools { + elem.Encode(e) + } + e.ArrEnd() } { - e.FieldStart("url") - e.Str(s.URL) + e.FieldStart("implementations") + s.Implementations.Encode(e) } } -var jsonFieldsNameOfImagePreview = [2]string{ - 0: "resolution", - 1: "url", +var jsonFieldsNameOfGetStakingPoolsOK = [2]string{ + 0: "pools", + 1: "implementations", } -// Decode decodes ImagePreview from json. -func (s *ImagePreview) Decode(d *jx.Decoder) error { +// Decode decodes GetStakingPoolsOK from json. +func (s *GetStakingPoolsOK) 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 GetStakingPoolsOK to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "resolution": + case "pools": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Resolution = 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 \"resolution\"") + return errors.Wrap(err, "decode field \"pools\"") } - case "url": + case "implementations": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.URL = string(v) - if err != nil { + if err := s.Implementations.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"url\"") + return errors.Wrap(err, "decode field \"implementations\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode ImagePreview") + return errors.Wrap(err, "decode GetStakingPoolsOK") } // Validate required fields. var failures []validate.FieldError @@ -23652,8 +23721,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(jsonFieldsNameOfGetStakingPoolsOK) { + name = jsonFieldsNameOfGetStakingPoolsOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -23674,293 +23743,133 @@ func (s *ImagePreview) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *ImagePreview) 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 *ImagePreview) UnmarshalJSON(data []byte) error { +func (s *GetStakingPoolsOK) 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 GetStakingPoolsOKImplementations) 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) - } - { - e.FieldStart("file_hash") - e.Str(s.FileHash) - } -} +// encodeFields implements json.Marshaler. +func (s GetStakingPoolsOKImplementations) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) -var jsonFieldsNameOfInitStateRaw = [3]string{ - 0: "workchain", - 1: "root_hash", - 2: "file_hash", + elem.Encode(e) + } } -// Decode decodes InitStateRaw from json. -func (s *InitStateRaw) Decode(d *jx.Decoder) error { +// Decode decodes GetStakingPoolsOKImplementations from json. +func (s *GetStakingPoolsOKImplementations) 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 GetStakingPoolsOKImplementations to nil") } - var requiredBitSet [1]uint8 - + m := s.init() if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - switch string(k) { - case "workchain": - 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\"") + var elem PoolImplementation + if err := func() error { + if err := elem.Decode(d); err != nil { + return err } - 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 { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"file_hash\"") - } - 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 InitStateRaw") - } - // 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(jsonFieldsNameOfInitStateRaw) { - name = jsonFieldsNameOfInitStateRaw[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 GetStakingPoolsOKImplementations") } return nil } // MarshalJSON implements stdjson.Marshaler. -func (s *InitStateRaw) 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 *InitStateRaw) 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 *JettonBalance) Encode(e *jx.Encoder) { +func (s *GetStorageProvidersOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonBalance) encodeFields(e *jx.Encoder) { - { - e.FieldStart("balance") - e.Str(s.Balance) - } - { - if s.Price.Set { - e.FieldStart("price") - s.Price.Encode(e) - } - } - { - e.FieldStart("wallet_address") - s.WalletAddress.Encode(e) - } - { - e.FieldStart("jetton") - s.Jetton.Encode(e) - } - { - if s.Extensions != nil { - e.FieldStart("extensions") - e.ArrStart() - for _, elem := range s.Extensions { - e.Str(elem) - } - e.ArrEnd() - } - } +func (s *GetStorageProvidersOK) encodeFields(e *jx.Encoder) { { - if s.Lock.Set { - e.FieldStart("lock") - s.Lock.Encode(e) + e.FieldStart("providers") + e.ArrStart() + for _, elem := range s.Providers { + elem.Encode(e) } + e.ArrEnd() } } -var jsonFieldsNameOfJettonBalance = [6]string{ - 0: "balance", - 1: "price", - 2: "wallet_address", - 3: "jetton", - 4: "extensions", - 5: "lock", +var jsonFieldsNameOfGetStorageProvidersOK = [1]string{ + 0: "providers", } -// Decode decodes JettonBalance from json. -func (s *JettonBalance) 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 JettonBalance 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 "balance": + case "providers": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Balance = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"balance\"") - } - case "price": - if err := func() error { - s.Price.Reset() - if err := s.Price.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"price\"") - } - case "wallet_address": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - if err := s.WalletAddress.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"wallet_address\"") - } - case "jetton": - requiredBitSet[0] |= 1 << 3 - 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 "extensions": - if err := func() error { - s.Extensions = make([]string, 0) + s.Providers = make([]StorageProvider, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem string - v, err := d.Str() - elem = string(v) - if err != nil { + var elem StorageProvider + if err := elem.Decode(d); err != nil { return err } - s.Extensions = append(s.Extensions, elem) + s.Providers = append(s.Providers, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"extensions\"") - } - case "lock": - if err := func() error { - s.Lock.Reset() - if err := s.Lock.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"lock\"") + return errors.Wrap(err, "decode field \"providers\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonBalance") + return errors.Wrap(err, "decode GetStorageProvidersOK") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00001101, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -23972,8 +23881,8 @@ func (s *JettonBalance) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonBalance) { - name = jsonFieldsNameOfJettonBalance[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetStorageProvidersOK) { + name = jsonFieldsNameOfGetStorageProvidersOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -23994,86 +23903,69 @@ func (s *JettonBalance) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonBalance) 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 *JettonBalance) 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 *JettonBalanceLock) Encode(e *jx.Encoder) { +func (s *GetTonConnectPayloadOK) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonBalanceLock) encodeFields(e *jx.Encoder) { - { - e.FieldStart("amount") - e.Str(s.Amount) - } +func (s *GetTonConnectPayloadOK) encodeFields(e *jx.Encoder) { { - e.FieldStart("till") - e.Int64(s.Till) + e.FieldStart("payload") + e.Str(s.Payload) } } -var jsonFieldsNameOfJettonBalanceLock = [2]string{ - 0: "amount", - 1: "till", +var jsonFieldsNameOfGetTonConnectPayloadOK = [1]string{ + 0: "payload", } -// Decode decodes JettonBalanceLock from json. -func (s *JettonBalanceLock) 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 JettonBalanceLock 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 "amount": + case "payload": requiredBitSet[0] |= 1 << 0 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 "till": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Int64() - s.Till = int64(v) + s.Payload = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"till\"") + return errors.Wrap(err, "decode field \"payload\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonBalanceLock") + return errors.Wrap(err, "decode GetTonConnectPayloadOK") } // 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. @@ -24085,8 +23977,8 @@ func (s *JettonBalanceLock) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonBalanceLock) { - name = jsonFieldsNameOfJettonBalanceLock[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetTonConnectPayloadOK) { + name = jsonFieldsNameOfGetTonConnectPayloadOK[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -24107,181 +23999,81 @@ func (s *JettonBalanceLock) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonBalanceLock) 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 *JettonBalanceLock) UnmarshalJSON(data []byte) error { +func (s *GetTonConnectPayloadOK) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonBridgeParams) Encode(e *jx.Encoder) { +func (s *GetWalletsByPublicKeyBulkReq) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonBridgeParams) encodeFields(e *jx.Encoder) { +func (s *GetWalletsByPublicKeyBulkReq) encodeFields(e *jx.Encoder) { { - e.FieldStart("bridge_address") - e.Str(s.BridgeAddress) - } - { - e.FieldStart("oracles_address") - e.Str(s.OraclesAddress) - } - { - e.FieldStart("state_flags") - e.Int(s.StateFlags) - } - { - if s.BurnBridgeFee.Set { - e.FieldStart("burn_bridge_fee") - s.BurnBridgeFee.Encode(e) - } - } - { - e.FieldStart("oracles") + e.FieldStart("public_keys") e.ArrStart() - for _, elem := range s.Oracles { - elem.Encode(e) + for _, elem := range s.PublicKeys { + e.Str(elem) } e.ArrEnd() } - { - if s.ExternalChainAddress.Set { - e.FieldStart("external_chain_address") - s.ExternalChainAddress.Encode(e) - } - } - { - if s.Prices.Set { - e.FieldStart("prices") - s.Prices.Encode(e) - } - } } -var jsonFieldsNameOfJettonBridgeParams = [7]string{ - 0: "bridge_address", - 1: "oracles_address", - 2: "state_flags", - 3: "burn_bridge_fee", - 4: "oracles", - 5: "external_chain_address", - 6: "prices", +var jsonFieldsNameOfGetWalletsByPublicKeyBulkReq = [1]string{ + 0: "public_keys", } -// Decode decodes JettonBridgeParams from json. -func (s *JettonBridgeParams) Decode(d *jx.Decoder) error { +// Decode decodes GetWalletsByPublicKeyBulkReq from json. +func (s *GetWalletsByPublicKeyBulkReq) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode JettonBridgeParams to nil") + return errors.New("invalid: unable to decode GetWalletsByPublicKeyBulkReq to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "bridge_address": + case "public_keys": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.BridgeAddress = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"bridge_address\"") - } - case "oracles_address": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Str() - s.OraclesAddress = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"oracles_address\"") - } - case "state_flags": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Int() - s.StateFlags = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"state_flags\"") - } - case "burn_bridge_fee": - if err := func() error { - s.BurnBridgeFee.Reset() - if err := s.BurnBridgeFee.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"burn_bridge_fee\"") - } - case "oracles": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - s.Oracles = make([]Oracle, 0) + s.PublicKeys = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem Oracle - if err := elem.Decode(d); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } - s.Oracles = append(s.Oracles, elem) + s.PublicKeys = append(s.PublicKeys, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"oracles\"") - } - case "external_chain_address": - if err := func() error { - s.ExternalChainAddress.Reset() - if err := s.ExternalChainAddress.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"external_chain_address\"") - } - case "prices": - if err := func() error { - s.Prices.Reset() - if err := s.Prices.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"prices\"") + return errors.Wrap(err, "decode field \"public_keys\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonBridgeParams") + return errors.Wrap(err, "decode GetWalletsByPublicKeyBulkReq") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00010111, + 0b00000001, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -24293,8 +24085,8 @@ func (s *JettonBridgeParams) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonBridgeParams) { - name = jsonFieldsNameOfJettonBridgeParams[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfGetWalletsByPublicKeyBulkReq) { + name = jsonFieldsNameOfGetWalletsByPublicKeyBulkReq[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -24315,154 +24107,86 @@ func (s *JettonBridgeParams) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonBridgeParams) MarshalJSON() ([]byte, error) { +func (s *GetWalletsByPublicKeyBulkReq) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonBridgeParams) UnmarshalJSON(data []byte) error { +func (s *GetWalletsByPublicKeyBulkReq) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonBridgePrices) Encode(e *jx.Encoder) { +func (s *ImagePreview) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonBridgePrices) encodeFields(e *jx.Encoder) { - { - e.FieldStart("bridge_burn_fee") - e.Int64(s.BridgeBurnFee) - } - { - e.FieldStart("bridge_mint_fee") - e.Int64(s.BridgeMintFee) - } - { - e.FieldStart("wallet_min_tons_for_storage") - e.Int64(s.WalletMinTonsForStorage) - } - { - e.FieldStart("wallet_gas_consumption") - e.Int64(s.WalletGasConsumption) - } +func (s *ImagePreview) encodeFields(e *jx.Encoder) { { - e.FieldStart("minter_min_tons_for_storage") - e.Int64(s.MinterMinTonsForStorage) + e.FieldStart("resolution") + e.Str(s.Resolution) } { - e.FieldStart("discover_gas_consumption") - e.Int64(s.DiscoverGasConsumption) + e.FieldStart("url") + e.Str(s.URL) } } -var jsonFieldsNameOfJettonBridgePrices = [6]string{ - 0: "bridge_burn_fee", - 1: "bridge_mint_fee", - 2: "wallet_min_tons_for_storage", - 3: "wallet_gas_consumption", - 4: "minter_min_tons_for_storage", - 5: "discover_gas_consumption", +var jsonFieldsNameOfImagePreview = [2]string{ + 0: "resolution", + 1: "url", } -// Decode decodes JettonBridgePrices from json. -func (s *JettonBridgePrices) Decode(d *jx.Decoder) error { +// Decode decodes ImagePreview from json. +func (s *ImagePreview) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode JettonBridgePrices to nil") + return errors.New("invalid: unable to decode ImagePreview to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "bridge_burn_fee": + case "resolution": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.BridgeBurnFee = int64(v) + v, err := d.Str() + s.Resolution = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"bridge_burn_fee\"") + return errors.Wrap(err, "decode field \"resolution\"") } - case "bridge_mint_fee": + case "url": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int64() - s.BridgeMintFee = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"bridge_mint_fee\"") - } - case "wallet_min_tons_for_storage": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Int64() - s.WalletMinTonsForStorage = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"wallet_min_tons_for_storage\"") - } - case "wallet_gas_consumption": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Int64() - s.WalletGasConsumption = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"wallet_gas_consumption\"") - } - case "minter_min_tons_for_storage": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Int64() - s.MinterMinTonsForStorage = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"minter_min_tons_for_storage\"") - } - case "discover_gas_consumption": - requiredBitSet[0] |= 1 << 5 - if err := func() error { - v, err := d.Int64() - s.DiscoverGasConsumption = int64(v) + v, err := d.Str() + s.URL = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"discover_gas_consumption\"") + return errors.Wrap(err, "decode field \"url\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonBridgePrices") + return errors.Wrap(err, "decode ImagePreview") } // 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. @@ -24474,8 +24198,8 @@ func (s *JettonBridgePrices) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonBridgePrices) { - name = jsonFieldsNameOfJettonBridgePrices[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfImagePreview) { + name = jsonFieldsNameOfImagePreview[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -24496,116 +24220,103 @@ func (s *JettonBridgePrices) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonBridgePrices) 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 *JettonBridgePrices) 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 *JettonBurnAction) Encode(e *jx.Encoder) { +func (s *InitStateRaw) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonBurnAction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("sender") - s.Sender.Encode(e) - } +func (s *InitStateRaw) encodeFields(e *jx.Encoder) { { - e.FieldStart("senders_wallet") - e.Str(s.SendersWallet) + e.FieldStart("workchain") + e.Int32(s.Workchain) } { - e.FieldStart("amount") - e.Str(s.Amount) + e.FieldStart("root_hash") + e.Str(s.RootHash) } { - e.FieldStart("jetton") - s.Jetton.Encode(e) + e.FieldStart("file_hash") + e.Str(s.FileHash) } } -var jsonFieldsNameOfJettonBurnAction = [4]string{ - 0: "sender", - 1: "senders_wallet", - 2: "amount", - 3: "jetton", +var jsonFieldsNameOfInitStateRaw = [3]string{ + 0: "workchain", + 1: "root_hash", + 2: "file_hash", } -// Decode decodes JettonBurnAction from json. -func (s *JettonBurnAction) 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 JettonBurnAction 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 "senders_wallet": + case "root_hash": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.SendersWallet = string(v) + s.RootHash = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"senders_wallet\"") + return errors.Wrap(err, "decode field \"root_hash\"") } - case "amount": + case "file_hash": requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.Amount = string(v) + s.FileHash = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") - } - case "jetton": - requiredBitSet[0] |= 1 << 3 - 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\"") + return errors.Wrap(err, "decode field \"file_hash\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonBurnAction") + return errors.Wrap(err, "decode InitStateRaw") } // 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. @@ -24617,8 +24328,8 @@ func (s *JettonBurnAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonBurnAction) { - name = jsonFieldsNameOfJettonBurnAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfInitStateRaw) { + name = jsonFieldsNameOfInitStateRaw[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -24639,96 +24350,163 @@ func (s *JettonBurnAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonBurnAction) 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 *JettonBurnAction) UnmarshalJSON(data []byte) error { +func (s *InitStateRaw) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonHolders) Encode(e *jx.Encoder) { +func (s *JettonBalance) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonHolders) encodeFields(e *jx.Encoder) { +func (s *JettonBalance) encodeFields(e *jx.Encoder) { { - e.FieldStart("addresses") - e.ArrStart() - for _, elem := range s.Addresses { - elem.Encode(e) + e.FieldStart("balance") + e.Str(s.Balance) + } + { + if s.Price.Set { + e.FieldStart("price") + s.Price.Encode(e) } - e.ArrEnd() } { - e.FieldStart("total") - e.Int64(s.Total) + e.FieldStart("wallet_address") + s.WalletAddress.Encode(e) + } + { + e.FieldStart("jetton") + s.Jetton.Encode(e) + } + { + if s.Extensions != nil { + e.FieldStart("extensions") + e.ArrStart() + for _, elem := range s.Extensions { + e.Str(elem) + } + e.ArrEnd() + } + } + { + if s.Lock.Set { + e.FieldStart("lock") + s.Lock.Encode(e) + } } } -var jsonFieldsNameOfJettonHolders = [2]string{ - 0: "addresses", - 1: "total", +var jsonFieldsNameOfJettonBalance = [6]string{ + 0: "balance", + 1: "price", + 2: "wallet_address", + 3: "jetton", + 4: "extensions", + 5: "lock", } -// Decode decodes JettonHolders from json. -func (s *JettonHolders) Decode(d *jx.Decoder) error { +// Decode decodes JettonBalance from json. +func (s *JettonBalance) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode JettonHolders to nil") + return errors.New("invalid: unable to decode JettonBalance to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "addresses": + case "balance": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Addresses = make([]JettonHoldersAddressesItem, 0) + v, err := d.Str() + s.Balance = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"balance\"") + } + case "price": + if err := func() error { + s.Price.Reset() + if err := s.Price.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"price\"") + } + case "wallet_address": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + if err := s.WalletAddress.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"wallet_address\"") + } + case "jetton": + requiredBitSet[0] |= 1 << 3 + 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 "extensions": + if err := func() error { + s.Extensions = make([]string, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem JettonHoldersAddressesItem - if err := elem.Decode(d); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } - s.Addresses = append(s.Addresses, elem) + s.Extensions = append(s.Extensions, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"addresses\"") + return errors.Wrap(err, "decode field \"extensions\"") } - case "total": - requiredBitSet[0] |= 1 << 1 + case "lock": if err := func() error { - v, err := d.Int64() - s.Total = int64(v) - if err != nil { + s.Lock.Reset() + if err := s.Lock.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"total\"") + return errors.Wrap(err, "decode field \"lock\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonHolders") + return errors.Wrap(err, "decode JettonBalance") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000011, + 0b00001101, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -24740,8 +24518,8 @@ func (s *JettonHolders) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonHolders) { - name = jsonFieldsNameOfJettonHolders[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonBalance) { + name = jsonFieldsNameOfJettonBalance[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -24762,101 +24540,86 @@ func (s *JettonHolders) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonHolders) MarshalJSON() ([]byte, error) { +func (s *JettonBalance) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonHolders) UnmarshalJSON(data []byte) error { +func (s *JettonBalance) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonHoldersAddressesItem) Encode(e *jx.Encoder) { +func (s *JettonBalanceLock) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonHoldersAddressesItem) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } +func (s *JettonBalanceLock) encodeFields(e *jx.Encoder) { { - e.FieldStart("owner") - s.Owner.Encode(e) + e.FieldStart("amount") + e.Str(s.Amount) } { - e.FieldStart("balance") - e.Str(s.Balance) + e.FieldStart("till") + e.Int64(s.Till) } } -var jsonFieldsNameOfJettonHoldersAddressesItem = [3]string{ - 0: "address", - 1: "owner", - 2: "balance", +var jsonFieldsNameOfJettonBalanceLock = [2]string{ + 0: "amount", + 1: "till", } -// Decode decodes JettonHoldersAddressesItem from json. -func (s *JettonHoldersAddressesItem) Decode(d *jx.Decoder) error { +// Decode decodes JettonBalanceLock from json. +func (s *JettonBalanceLock) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode JettonHoldersAddressesItem to nil") + return errors.New("invalid: unable to decode JettonBalanceLock 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) + s.Amount = string(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 "owner": + case "till": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.Owner.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"owner\"") - } - case "balance": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Str() - s.Balance = string(v) + v, err := d.Int64() + s.Till = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"balance\"") + return errors.Wrap(err, "decode field \"till\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonHoldersAddressesItem") + return errors.Wrap(err, "decode JettonBalanceLock") } // 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. @@ -24868,8 +24631,8 @@ func (s *JettonHoldersAddressesItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonHoldersAddressesItem) { - name = jsonFieldsNameOfJettonHoldersAddressesItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonBalanceLock) { + name = jsonFieldsNameOfJettonBalanceLock[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -24890,283 +24653,362 @@ func (s *JettonHoldersAddressesItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonHoldersAddressesItem) MarshalJSON() ([]byte, error) { +func (s *JettonBalanceLock) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonHoldersAddressesItem) UnmarshalJSON(data []byte) error { +func (s *JettonBalanceLock) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonInfo) Encode(e *jx.Encoder) { +func (s *JettonBridgeParams) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonInfo) encodeFields(e *jx.Encoder) { - { - e.FieldStart("mintable") - e.Bool(s.Mintable) - } - { - e.FieldStart("total_supply") - e.Str(s.TotalSupply) - } - { - if s.Admin.Set { - e.FieldStart("admin") - s.Admin.Encode(e) - } - } - { - e.FieldStart("metadata") - s.Metadata.Encode(e) - } - { - e.FieldStart("preview") - e.Str(s.Preview) - } - { - e.FieldStart("verification") - s.Verification.Encode(e) - } +func (s *JettonBridgeParams) encodeFields(e *jx.Encoder) { { - e.FieldStart("holders_count") - e.Int32(s.HoldersCount) + e.FieldStart("bridge_address") + e.Str(s.BridgeAddress) } { - if s.ScaledUI.Set { - e.FieldStart("scaled_ui") - s.ScaledUI.Encode(e) - } + e.FieldStart("oracles_address") + e.Str(s.OraclesAddress) } { - if s.CodeHash.Set { - e.FieldStart("code_hash") - s.CodeHash.Encode(e) - } + e.FieldStart("state_flags") + e.Int(s.StateFlags) } { - if s.DataHash.Set { - e.FieldStart("data_hash") - s.DataHash.Encode(e) + if s.BurnBridgeFee.Set { + e.FieldStart("burn_bridge_fee") + s.BurnBridgeFee.Encode(e) } } { - if s.LastTransactionLt.Set { - e.FieldStart("last_transaction_lt") - s.LastTransactionLt.Encode(e) + e.FieldStart("oracles") + e.ArrStart() + for _, elem := range s.Oracles { + elem.Encode(e) } + e.ArrEnd() } { - if s.Name.Set { - e.FieldStart("name") - s.Name.Encode(e) + if s.ExternalChainAddress.Set { + e.FieldStart("external_chain_address") + s.ExternalChainAddress.Encode(e) } } { - if s.Interfaces != nil { - e.FieldStart("interfaces") - e.ArrStart() - for _, elem := range s.Interfaces { - e.Str(elem) - } - e.ArrEnd() + if s.Prices.Set { + e.FieldStart("prices") + s.Prices.Encode(e) } } } -var jsonFieldsNameOfJettonInfo = [13]string{ - 0: "mintable", - 1: "total_supply", - 2: "admin", - 3: "metadata", - 4: "preview", - 5: "verification", - 6: "holders_count", - 7: "scaled_ui", - 8: "code_hash", - 9: "data_hash", - 10: "last_transaction_lt", - 11: "name", - 12: "interfaces", +var jsonFieldsNameOfJettonBridgeParams = [7]string{ + 0: "bridge_address", + 1: "oracles_address", + 2: "state_flags", + 3: "burn_bridge_fee", + 4: "oracles", + 5: "external_chain_address", + 6: "prices", } -// Decode decodes JettonInfo from json. -func (s *JettonInfo) Decode(d *jx.Decoder) error { +// Decode decodes JettonBridgeParams from json. +func (s *JettonBridgeParams) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode JettonInfo to nil") + return errors.New("invalid: unable to decode JettonBridgeParams 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 "mintable": + case "bridge_address": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Bool() - s.Mintable = bool(v) + v, err := d.Str() + s.BridgeAddress = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"mintable\"") + return errors.Wrap(err, "decode field \"bridge_address\"") } - case "total_supply": + case "oracles_address": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.TotalSupply = string(v) + s.OraclesAddress = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"total_supply\"") + return errors.Wrap(err, "decode field \"oracles_address\"") } - case "admin": + case "state_flags": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Admin.Reset() - if err := s.Admin.Decode(d); err != nil { + v, err := d.Int() + s.StateFlags = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"admin\"") + return errors.Wrap(err, "decode field \"state_flags\"") } - case "metadata": - requiredBitSet[0] |= 1 << 3 + case "burn_bridge_fee": if err := func() error { - if err := s.Metadata.Decode(d); err != nil { + s.BurnBridgeFee.Reset() + if err := s.BurnBridgeFee.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"metadata\"") + return errors.Wrap(err, "decode field \"burn_bridge_fee\"") } - case "preview": + case "oracles": 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 { + s.Oracles = make([]Oracle, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem Oracle + if err := elem.Decode(d); err != nil { + return err + } + s.Oracles = append(s.Oracles, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"verification\"") + return errors.Wrap(err, "decode field \"oracles\"") } - case "holders_count": - requiredBitSet[0] |= 1 << 6 + case "external_chain_address": if err := func() error { - v, err := d.Int32() - s.HoldersCount = int32(v) - if err != nil { + s.ExternalChainAddress.Reset() + if err := s.ExternalChainAddress.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"holders_count\"") + return errors.Wrap(err, "decode field \"external_chain_address\"") } - case "scaled_ui": + case "prices": if err := func() error { - s.ScaledUI.Reset() - if err := s.ScaledUI.Decode(d); 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 \"scaled_ui\"") + return errors.Wrap(err, "decode field \"prices\"") } - case "code_hash": - if err := func() error { - s.CodeHash.Reset() - if err := s.CodeHash.Decode(d); err != nil { - return err + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode JettonBridgeParams") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00010111, + } { + 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(jsonFieldsNameOfJettonBridgeParams) { + name = jsonFieldsNameOfJettonBridgeParams[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"code_hash\"") + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx } - case "data_hash": - if err := func() error { - s.DataHash.Reset() - if err := s.DataHash.Decode(d); err != nil { - return err - } - return nil + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *JettonBridgeParams) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *JettonBridgeParams) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *JettonBridgePrices) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *JettonBridgePrices) encodeFields(e *jx.Encoder) { + { + e.FieldStart("bridge_burn_fee") + e.Int64(s.BridgeBurnFee) + } + { + e.FieldStart("bridge_mint_fee") + e.Int64(s.BridgeMintFee) + } + { + e.FieldStart("wallet_min_tons_for_storage") + e.Int64(s.WalletMinTonsForStorage) + } + { + e.FieldStart("wallet_gas_consumption") + e.Int64(s.WalletGasConsumption) + } + { + e.FieldStart("minter_min_tons_for_storage") + e.Int64(s.MinterMinTonsForStorage) + } + { + e.FieldStart("discover_gas_consumption") + e.Int64(s.DiscoverGasConsumption) + } +} + +var jsonFieldsNameOfJettonBridgePrices = [6]string{ + 0: "bridge_burn_fee", + 1: "bridge_mint_fee", + 2: "wallet_min_tons_for_storage", + 3: "wallet_gas_consumption", + 4: "minter_min_tons_for_storage", + 5: "discover_gas_consumption", +} + +// Decode decodes JettonBridgePrices from json. +func (s *JettonBridgePrices) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode JettonBridgePrices to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "bridge_burn_fee": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int64() + s.BridgeBurnFee = int64(v) + if err != nil { + return err + } + return nil }(); err != nil { - return errors.Wrap(err, "decode field \"data_hash\"") + return errors.Wrap(err, "decode field \"bridge_burn_fee\"") } - case "last_transaction_lt": + case "bridge_mint_fee": + requiredBitSet[0] |= 1 << 1 if err := func() error { - s.LastTransactionLt.Reset() - if err := s.LastTransactionLt.Decode(d); err != nil { + v, err := d.Int64() + s.BridgeMintFee = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"last_transaction_lt\"") + return errors.Wrap(err, "decode field \"bridge_mint_fee\"") } - case "name": + case "wallet_min_tons_for_storage": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Name.Reset() - if err := s.Name.Decode(d); err != nil { + v, err := d.Int64() + s.WalletMinTonsForStorage = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"name\"") + return errors.Wrap(err, "decode field \"wallet_min_tons_for_storage\"") } - case "interfaces": + case "wallet_gas_consumption": + requiredBitSet[0] |= 1 << 3 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.Int64() + s.WalletGasConsumption = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"interfaces\"") + return errors.Wrap(err, "decode field \"wallet_gas_consumption\"") + } + case "minter_min_tons_for_storage": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int64() + s.MinterMinTonsForStorage = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"minter_min_tons_for_storage\"") + } + case "discover_gas_consumption": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Int64() + s.DiscoverGasConsumption = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"discover_gas_consumption\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonInfo") + return errors.Wrap(err, "decode JettonBridgePrices") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [2]uint8{ - 0b01111011, - 0b00000000, + 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. @@ -25178,8 +25020,8 @@ func (s *JettonInfo) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonInfo) { - name = jsonFieldsNameOfJettonInfo[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonBridgePrices) { + name = jsonFieldsNameOfJettonBridgePrices[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -25200,262 +25042,116 @@ func (s *JettonInfo) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonInfo) MarshalJSON() ([]byte, error) { +func (s *JettonBridgePrices) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonInfo) UnmarshalJSON(data []byte) error { +func (s *JettonBridgePrices) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonMetadata) Encode(e *jx.Encoder) { +func (s *JettonBurnAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonMetadata) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } - { - e.FieldStart("name") - e.Str(s.Name) - } - { - e.FieldStart("symbol") - e.Str(s.Symbol) - } - { - e.FieldStart("decimals") - e.Str(s.Decimals) - } - { - if s.Image.Set { - e.FieldStart("image") - s.Image.Encode(e) - } - } - { - if s.Description.Set { - e.FieldStart("description") - s.Description.Encode(e) - } - } +func (s *JettonBurnAction) encodeFields(e *jx.Encoder) { { - if s.Social != nil { - e.FieldStart("social") - e.ArrStart() - for _, elem := range s.Social { - e.Str(elem) - } - e.ArrEnd() - } + e.FieldStart("sender") + s.Sender.Encode(e) } { - if s.Websites != nil { - e.FieldStart("websites") - e.ArrStart() - for _, elem := range s.Websites { - e.Str(elem) - } - e.ArrEnd() - } + e.FieldStart("senders_wallet") + e.Str(s.SendersWallet) } { - if s.Catalogs != nil { - e.FieldStart("catalogs") - e.ArrStart() - for _, elem := range s.Catalogs { - e.Str(elem) - } - e.ArrEnd() - } + e.FieldStart("amount") + e.Str(s.Amount) } { - if s.CustomPayloadAPIURI.Set { - e.FieldStart("custom_payload_api_uri") - s.CustomPayloadAPIURI.Encode(e) - } + e.FieldStart("jetton") + s.Jetton.Encode(e) } } -var jsonFieldsNameOfJettonMetadata = [10]string{ - 0: "address", - 1: "name", - 2: "symbol", - 3: "decimals", - 4: "image", - 5: "description", - 6: "social", - 7: "websites", - 8: "catalogs", - 9: "custom_payload_api_uri", +var jsonFieldsNameOfJettonBurnAction = [4]string{ + 0: "sender", + 1: "senders_wallet", + 2: "amount", + 3: "jetton", } -// Decode decodes JettonMetadata from json. -func (s *JettonMetadata) Decode(d *jx.Decoder) error { +// Decode decodes JettonBurnAction from json. +func (s *JettonBurnAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode JettonMetadata to nil") + return errors.New("invalid: unable to decode JettonBurnAction 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 "sender": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Address = string(v) - if err != nil { + if err := s.Sender.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") + return errors.Wrap(err, "decode field \"sender\"") } - case "name": + case "senders_wallet": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.Name = string(v) + s.SendersWallet = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"name\"") + return errors.Wrap(err, "decode field \"senders_wallet\"") } - case "symbol": + case "amount": requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.Symbol = string(v) + s.Amount = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"symbol\"") + return errors.Wrap(err, "decode field \"amount\"") } - case "decimals": + case "jetton": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Str() - s.Decimals = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"decimals\"") - } - 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\"") - } - case "description": - if err := func() error { - s.Description.Reset() - if err := s.Description.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"description\"") - } - case "social": - if err := func() error { - s.Social = 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.Social = append(s.Social, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"social\"") - } - case "websites": - if err := func() error { - s.Websites = 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.Websites = append(s.Websites, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"websites\"") - } - case "catalogs": - if err := func() error { - s.Catalogs = 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.Catalogs = append(s.Catalogs, elem) - return nil - }); err != nil { - return err - } - return nil - }(); 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 { + if err := s.Jetton.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"custom_payload_api_uri\"") + return errors.Wrap(err, "decode field \"jetton\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonMetadata") + return errors.Wrap(err, "decode JettonBurnAction") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [2]uint8{ + for i, mask := range [1]uint8{ 0b00001111, - 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -25467,8 +25163,8 @@ func (s *JettonMetadata) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonMetadata) { - name = jsonFieldsNameOfJettonMetadata[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonBurnAction) { + name = jsonFieldsNameOfJettonBurnAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -25489,116 +25185,96 @@ func (s *JettonMetadata) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonMetadata) MarshalJSON() ([]byte, error) { +func (s *JettonBurnAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonMetadata) UnmarshalJSON(data []byte) error { +func (s *JettonBurnAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonMintAction) Encode(e *jx.Encoder) { +func (s *JettonHolders) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonMintAction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("recipient") - s.Recipient.Encode(e) - } - { - e.FieldStart("recipients_wallet") - e.Str(s.RecipientsWallet) - } +func (s *JettonHolders) encodeFields(e *jx.Encoder) { { - e.FieldStart("amount") - e.Str(s.Amount) + e.FieldStart("addresses") + e.ArrStart() + for _, elem := range s.Addresses { + elem.Encode(e) + } + e.ArrEnd() } { - e.FieldStart("jetton") - s.Jetton.Encode(e) + e.FieldStart("total") + e.Int64(s.Total) } } -var jsonFieldsNameOfJettonMintAction = [4]string{ - 0: "recipient", - 1: "recipients_wallet", - 2: "amount", - 3: "jetton", +var jsonFieldsNameOfJettonHolders = [2]string{ + 0: "addresses", + 1: "total", } -// Decode decodes JettonMintAction from json. -func (s *JettonMintAction) Decode(d *jx.Decoder) error { +// Decode decodes JettonHolders from json. +func (s *JettonHolders) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode JettonMintAction to nil") + return errors.New("invalid: unable to decode JettonHolders to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "recipient": + case "addresses": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Recipient.Decode(d); err != nil { + s.Addresses = make([]JettonHoldersAddressesItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem JettonHoldersAddressesItem + 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 \"recipient\"") + return errors.Wrap(err, "decode field \"addresses\"") } - case "recipients_wallet": + case "total": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.RecipientsWallet = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"recipients_wallet\"") - } - case "amount": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Str() - s.Amount = string(v) + v, err := d.Int64() + s.Total = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount\"") - } - case "jetton": - requiredBitSet[0] |= 1 << 3 - 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\"") + return errors.Wrap(err, "decode field \"total\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonMintAction") + return errors.Wrap(err, "decode JettonHolders") } // 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. @@ -25610,8 +25286,8 @@ func (s *JettonMintAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonMintAction) { - name = jsonFieldsNameOfJettonMintAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonHolders) { + name = jsonFieldsNameOfJettonHolders[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -25632,237 +25308,101 @@ func (s *JettonMintAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonMintAction) MarshalJSON() ([]byte, error) { +func (s *JettonHolders) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonMintAction) UnmarshalJSON(data []byte) error { +func (s *JettonHolders) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonOperation) Encode(e *jx.Encoder) { +func (s *JettonHoldersAddressesItem) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonOperation) encodeFields(e *jx.Encoder) { +func (s *JettonHoldersAddressesItem) encodeFields(e *jx.Encoder) { { - e.FieldStart("operation") - s.Operation.Encode(e) + e.FieldStart("address") + e.Str(s.Address) } { - e.FieldStart("utime") - e.Int64(s.Utime) + e.FieldStart("owner") + s.Owner.Encode(e) } { - e.FieldStart("lt") - e.Int64(s.Lt) + e.FieldStart("balance") + e.Str(s.Balance) } - { - e.FieldStart("transaction_hash") - e.Str(s.TransactionHash) +} + +var jsonFieldsNameOfJettonHoldersAddressesItem = [3]string{ + 0: "address", + 1: "owner", + 2: "balance", +} + +// Decode decodes JettonHoldersAddressesItem from json. +func (s *JettonHoldersAddressesItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode JettonHoldersAddressesItem to nil") } - { - 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 + var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "operation": + case "address": 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) + s.Address = 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\"") + return errors.Wrap(err, "decode field \"address\"") } - case "trace_id": - requiredBitSet[1] |= 1 << 0 + case "owner": + requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.TraceID = string(v) - if err != nil { + if err := s.Owner.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"trace_id\"") + return errors.Wrap(err, "decode field \"owner\"") } - case "query_id": - requiredBitSet[1] |= 1 << 1 + case "balance": + requiredBitSet[0] |= 1 << 2 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) + s.Balance = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"payload\"") + return errors.Wrap(err, "decode field \"balance\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonOperation") + return errors.Wrap(err, "decode JettonHoldersAddressesItem") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [2]uint8{ - 0b11001111, - 0b00000011, + 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. @@ -25874,8 +25414,8 @@ func (s *JettonOperation) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonOperation) { - name = jsonFieldsNameOfJettonOperation[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonHoldersAddressesItem) { + name = jsonFieldsNameOfJettonHoldersAddressesItem[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -25896,321 +25436,179 @@ func (s *JettonOperation) Decode(d *jx.Decoder) error { } // 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) { +func (s *JettonHoldersAddressesItem) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonOperationOperation) UnmarshalJSON(data []byte) error { +func (s *JettonHoldersAddressesItem) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonOperations) Encode(e *jx.Encoder) { +func (s *JettonInfo) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonOperations) encodeFields(e *jx.Encoder) { +func (s *JettonInfo) encodeFields(e *jx.Encoder) { { - e.FieldStart("operations") - e.ArrStart() - for _, elem := range s.Operations { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("mintable") + e.Bool(s.Mintable) } { - if s.NextFrom.Set { - e.FieldStart("next_from") - s.NextFrom.Encode(e) - } + e.FieldStart("total_supply") + e.Str(s.TotalSupply) } -} - -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") + { + if s.Admin.Set { + e.FieldStart("admin") + s.Admin.Encode(e) + } } - 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() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *JettonPreview) encodeFields(e *jx.Encoder) { { - e.FieldStart("address") - e.Str(s.Address) + e.FieldStart("metadata") + s.Metadata.Encode(e) } { - e.FieldStart("name") - e.Str(s.Name) + e.FieldStart("preview") + e.Str(s.Preview) } { - e.FieldStart("symbol") - e.Str(s.Symbol) + e.FieldStart("verification") + s.Verification.Encode(e) } { - e.FieldStart("decimals") - e.Int(s.Decimals) + e.FieldStart("holders_count") + e.Int32(s.HoldersCount) } { - e.FieldStart("image") - e.Str(s.Image) + if s.ScaledUI.Set { + e.FieldStart("scaled_ui") + s.ScaledUI.Encode(e) + } } { - e.FieldStart("verification") - s.Verification.Encode(e) + if s.CodeHash.Set { + e.FieldStart("code_hash") + s.CodeHash.Encode(e) + } } { - if s.CustomPayloadAPIURI.Set { - e.FieldStart("custom_payload_api_uri") - s.CustomPayloadAPIURI.Encode(e) + if s.DataHash.Set { + e.FieldStart("data_hash") + s.DataHash.Encode(e) } } { - e.FieldStart("score") - e.Int32(s.Score) + if s.LastTransactionLt.Set { + e.FieldStart("last_transaction_lt") + s.LastTransactionLt.Encode(e) + } } { - if s.ScaledUI.Set { - e.FieldStart("scaled_ui") - s.ScaledUI.Encode(e) + if s.Name.Set { + e.FieldStart("name") + s.Name.Encode(e) } } { - if s.Description.Set { - e.FieldStart("description") - s.Description.Encode(e) + if s.Interfaces != nil { + e.FieldStart("interfaces") + e.ArrStart() + for _, elem := range s.Interfaces { + e.Str(elem) + } + e.ArrEnd() } } } -var jsonFieldsNameOfJettonPreview = [10]string{ - 0: "address", - 1: "name", - 2: "symbol", - 3: "decimals", - 4: "image", - 5: "verification", - 6: "custom_payload_api_uri", - 7: "score", - 8: "scaled_ui", - 9: "description", +var jsonFieldsNameOfJettonInfo = [13]string{ + 0: "mintable", + 1: "total_supply", + 2: "admin", + 3: "metadata", + 4: "preview", + 5: "verification", + 6: "holders_count", + 7: "scaled_ui", + 8: "code_hash", + 9: "data_hash", + 10: "last_transaction_lt", + 11: "name", + 12: "interfaces", } -// Decode decodes JettonPreview from json. -func (s *JettonPreview) Decode(d *jx.Decoder) error { +// Decode decodes JettonInfo from json. +func (s *JettonInfo) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode JettonPreview to nil") + return errors.New("invalid: unable to decode JettonInfo to nil") } var requiredBitSet [2]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "mintable": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Address = string(v) + v, err := d.Bool() + s.Mintable = bool(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") + return errors.Wrap(err, "decode field \"mintable\"") } - case "name": + case "total_supply": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.Name = string(v) + s.TotalSupply = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"name\"") + return errors.Wrap(err, "decode field \"total_supply\"") } - case "symbol": - requiredBitSet[0] |= 1 << 2 + case "admin": if err := func() error { - v, err := d.Str() - s.Symbol = string(v) - if err != nil { + s.Admin.Reset() + if err := s.Admin.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"symbol\"") + return errors.Wrap(err, "decode field \"admin\"") } - case "decimals": + case "metadata": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Int() - s.Decimals = int(v) - if err != nil { + if err := s.Metadata.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"decimals\"") + return errors.Wrap(err, "decode field \"metadata\"") } - case "image": + case "preview": requiredBitSet[0] |= 1 << 4 if err := func() error { v, err := d.Str() - s.Image = string(v) + s.Preview = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"image\"") + return errors.Wrap(err, "decode field \"preview\"") } case "verification": requiredBitSet[0] |= 1 << 5 @@ -26222,27 +25620,17 @@ 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 + case "holders_count": + requiredBitSet[0] |= 1 << 6 if err := func() error { v, err := d.Int32() - s.Score = int32(v) + s.HoldersCount = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"score\"") + return errors.Wrap(err, "decode field \"holders_count\"") } case "scaled_ui": if err := func() error { @@ -26254,154 +25642,77 @@ func (s *JettonPreview) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"scaled_ui\"") } - case "description": + case "code_hash": if err := func() error { - s.Description.Reset() - if err := s.Description.Decode(d); err != nil { + s.CodeHash.Reset() + if err := s.CodeHash.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"description\"") + return errors.Wrap(err, "decode field \"code_hash\"") } - default: - return d.Skip() - } - return nil - }); err != nil { - return errors.Wrap(err, "decode JettonPreview") - } - // Validate required fields. - var failures []validate.FieldError - for i, mask := range [2]uint8{ - 0b10111111, - 0b00000000, - } { - 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(jsonFieldsNameOfJettonPreview) { - name = jsonFieldsNameOfJettonPreview[fieldIdx] - } else { - name = strconv.Itoa(fieldIdx) + case "data_hash": + if err := func() error { + s.DataHash.Reset() + if err := s.DataHash.Decode(d); err != nil { + return err } - failures = append(failures, validate.FieldError{ - Name: name, - Error: validate.ErrFieldRequired, - }) - // Reset bit. - result &^= 1 << bitIdx + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"data_hash\"") } - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s *JettonPreview) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonPreview) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s *JettonQuantity) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *JettonQuantity) encodeFields(e *jx.Encoder) { - { - e.FieldStart("quantity") - e.Str(s.Quantity) - } - { - e.FieldStart("wallet_address") - s.WalletAddress.Encode(e) - } - { - e.FieldStart("jetton") - s.Jetton.Encode(e) - } -} - -var jsonFieldsNameOfJettonQuantity = [3]string{ - 0: "quantity", - 1: "wallet_address", - 2: "jetton", -} - -// Decode decodes JettonQuantity from json. -func (s *JettonQuantity) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode JettonQuantity to nil") - } - var requiredBitSet [1]uint8 - - if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - switch string(k) { - case "quantity": - requiredBitSet[0] |= 1 << 0 + case "last_transaction_lt": if err := func() error { - v, err := d.Str() - s.Quantity = string(v) - if err != nil { + s.LastTransactionLt.Reset() + if err := s.LastTransactionLt.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"quantity\"") + return errors.Wrap(err, "decode field \"last_transaction_lt\"") } - case "wallet_address": - requiredBitSet[0] |= 1 << 1 + case "name": if err := func() error { - if err := s.WalletAddress.Decode(d); err != nil { + s.Name.Reset() + if err := s.Name.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"wallet_address\"") + return errors.Wrap(err, "decode field \"name\"") } - case "jetton": - requiredBitSet[0] |= 1 << 2 + case "interfaces": if err := func() error { - if err := s.Jetton.Decode(d); err != nil { + 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 \"jetton\"") + return errors.Wrap(err, "decode field \"interfaces\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonQuantity") + return errors.Wrap(err, "decode JettonInfo") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ - 0b00000111, + for i, mask := range [2]uint8{ + 0b01111011, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -26413,8 +25724,8 @@ func (s *JettonQuantity) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonQuantity) { - name = jsonFieldsNameOfJettonQuantity[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonInfo) { + name = jsonFieldsNameOfJettonInfo[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -26435,201 +25746,261 @@ func (s *JettonQuantity) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonQuantity) MarshalJSON() ([]byte, error) { +func (s *JettonInfo) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonQuantity) UnmarshalJSON(data []byte) error { +func (s *JettonInfo) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonSwapAction) Encode(e *jx.Encoder) { +func (s *JettonMetadata) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonSwapAction) encodeFields(e *jx.Encoder) { +func (s *JettonMetadata) encodeFields(e *jx.Encoder) { { - e.FieldStart("dex") - e.Str(s.Dex) + e.FieldStart("address") + e.Str(s.Address) } { - e.FieldStart("amount_in") - e.Str(s.AmountIn) + e.FieldStart("name") + e.Str(s.Name) } { - e.FieldStart("amount_out") - e.Str(s.AmountOut) + e.FieldStart("symbol") + e.Str(s.Symbol) } { - if s.TonIn.Set { - e.FieldStart("ton_in") - s.TonIn.Encode(e) + e.FieldStart("decimals") + e.Str(s.Decimals) + } + { + if s.Image.Set { + e.FieldStart("image") + s.Image.Encode(e) } } { - if s.TonOut.Set { - e.FieldStart("ton_out") - s.TonOut.Encode(e) + if s.Description.Set { + e.FieldStart("description") + s.Description.Encode(e) } } { - e.FieldStart("user_wallet") - s.UserWallet.Encode(e) + if s.Social != nil { + e.FieldStart("social") + e.ArrStart() + for _, elem := range s.Social { + e.Str(elem) + } + e.ArrEnd() + } } { - e.FieldStart("router") - s.Router.Encode(e) + if s.Websites != nil { + e.FieldStart("websites") + e.ArrStart() + for _, elem := range s.Websites { + e.Str(elem) + } + e.ArrEnd() + } } { - if s.JettonMasterIn.Set { - e.FieldStart("jetton_master_in") - s.JettonMasterIn.Encode(e) + if s.Catalogs != nil { + e.FieldStart("catalogs") + e.ArrStart() + for _, elem := range s.Catalogs { + e.Str(elem) + } + e.ArrEnd() } } { - if s.JettonMasterOut.Set { - e.FieldStart("jetton_master_out") - s.JettonMasterOut.Encode(e) + if s.CustomPayloadAPIURI.Set { + e.FieldStart("custom_payload_api_uri") + s.CustomPayloadAPIURI.Encode(e) } } } -var jsonFieldsNameOfJettonSwapAction = [9]string{ - 0: "dex", - 1: "amount_in", - 2: "amount_out", - 3: "ton_in", - 4: "ton_out", - 5: "user_wallet", - 6: "router", - 7: "jetton_master_in", - 8: "jetton_master_out", +var jsonFieldsNameOfJettonMetadata = [10]string{ + 0: "address", + 1: "name", + 2: "symbol", + 3: "decimals", + 4: "image", + 5: "description", + 6: "social", + 7: "websites", + 8: "catalogs", + 9: "custom_payload_api_uri", } -// Decode decodes JettonSwapAction from json. -func (s *JettonSwapAction) Decode(d *jx.Decoder) error { +// Decode decodes JettonMetadata from json. +func (s *JettonMetadata) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode JettonSwapAction to nil") + return errors.New("invalid: unable to decode JettonMetadata to nil") } var requiredBitSet [2]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "dex": + case "address": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.Dex = string(v) + s.Address = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"dex\"") + return errors.Wrap(err, "decode field \"address\"") } - case "amount_in": + case "name": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.AmountIn = string(v) + s.Name = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount_in\"") + return errors.Wrap(err, "decode field \"name\"") } - case "amount_out": + case "symbol": requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() - s.AmountOut = string(v) + s.Symbol = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"amount_out\"") + return errors.Wrap(err, "decode field \"symbol\"") } - case "ton_in": + case "decimals": + requiredBitSet[0] |= 1 << 3 if err := func() error { - s.TonIn.Reset() - if err := s.TonIn.Decode(d); err != nil { + v, err := d.Str() + s.Decimals = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ton_in\"") + return errors.Wrap(err, "decode field \"decimals\"") } - case "ton_out": + case "image": if err := func() error { - s.TonOut.Reset() - if err := s.TonOut.Decode(d); err != nil { + s.Image.Reset() + if err := s.Image.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ton_out\"") + return errors.Wrap(err, "decode field \"image\"") } - case "user_wallet": - requiredBitSet[0] |= 1 << 5 + case "description": if err := func() error { - if err := s.UserWallet.Decode(d); err != nil { + s.Description.Reset() + if err := s.Description.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"user_wallet\"") + return errors.Wrap(err, "decode field \"description\"") } - case "router": - requiredBitSet[0] |= 1 << 6 + case "social": if err := func() error { - if err := s.Router.Decode(d); err != nil { + s.Social = 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.Social = append(s.Social, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"router\"") + return errors.Wrap(err, "decode field \"social\"") } - case "jetton_master_in": + case "websites": if err := func() error { - s.JettonMasterIn.Reset() - if err := s.JettonMasterIn.Decode(d); err != nil { + s.Websites = 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.Websites = append(s.Websites, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"jetton_master_in\"") + return errors.Wrap(err, "decode field \"websites\"") } - case "jetton_master_out": + case "catalogs": if err := func() error { - s.JettonMasterOut.Reset() - if err := s.JettonMasterOut.Decode(d); err != nil { + s.Catalogs = 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.Catalogs = append(s.Catalogs, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"jetton_master_out\"") + 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() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonSwapAction") + return errors.Wrap(err, "decode JettonMetadata") } // Validate required fields. var failures []validate.FieldError for i, mask := range [2]uint8{ - 0b01100111, + 0b00001111, 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { @@ -26642,8 +26013,8 @@ func (s *JettonSwapAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonSwapAction) { - name = jsonFieldsNameOfJettonSwapAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonMetadata) { + name = jsonFieldsNameOfJettonMetadata[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -26664,42 +26035,30 @@ func (s *JettonSwapAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonSwapAction) MarshalJSON() ([]byte, error) { +func (s *JettonMetadata) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonSwapAction) UnmarshalJSON(data []byte) error { +func (s *JettonMetadata) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonTransferAction) Encode(e *jx.Encoder) { +func (s *JettonMintAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonTransferAction) encodeFields(e *jx.Encoder) { - { - if s.Sender.Set { - e.FieldStart("sender") - s.Sender.Encode(e) - } - } - { - if s.Recipient.Set { - e.FieldStart("recipient") - s.Recipient.Encode(e) - } - } +func (s *JettonMintAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("senders_wallet") - e.Str(s.SendersWallet) + e.FieldStart("recipient") + s.Recipient.Encode(e) } { e.FieldStart("recipients_wallet") @@ -26709,64 +26068,31 @@ func (s *JettonTransferAction) encodeFields(e *jx.Encoder) { e.FieldStart("amount") e.Str(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) - } - } { e.FieldStart("jetton") s.Jetton.Encode(e) } } -var jsonFieldsNameOfJettonTransferAction = [9]string{ - 0: "sender", - 1: "recipient", - 2: "senders_wallet", - 3: "recipients_wallet", - 4: "amount", - 5: "comment", - 6: "encrypted_comment", - 7: "refund", - 8: "jetton", +var jsonFieldsNameOfJettonMintAction = [4]string{ + 0: "recipient", + 1: "recipients_wallet", + 2: "amount", + 3: "jetton", } -// Decode decodes JettonTransferAction from json. -func (s *JettonTransferAction) Decode(d *jx.Decoder) error { +// Decode decodes JettonMintAction from json. +func (s *JettonMintAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode JettonTransferAction to nil") + return errors.New("invalid: unable to decode JettonMintAction 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 "sender": - if err := func() error { - s.Sender.Reset() - 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 << 0 if err := func() error { - s.Recipient.Reset() if err := s.Recipient.Decode(d); err != nil { return err } @@ -26774,20 +26100,8 @@ func (s *JettonTransferAction) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"recipient\"") } - case "senders_wallet": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Str() - s.SendersWallet = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"senders_wallet\"") - } case "recipients_wallet": - requiredBitSet[0] |= 1 << 3 + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() s.RecipientsWallet = string(v) @@ -26799,7 +26113,7 @@ func (s *JettonTransferAction) Decode(d *jx.Decoder) error { return errors.Wrap(err, "decode field \"recipients_wallet\"") } case "amount": - requiredBitSet[0] |= 1 << 4 + requiredBitSet[0] |= 1 << 2 if err := func() error { v, err := d.Str() s.Amount = string(v) @@ -26810,38 +26124,8 @@ func (s *JettonTransferAction) Decode(d *jx.Decoder) error { }(); 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\"") - } case "jetton": - requiredBitSet[1] |= 1 << 0 + requiredBitSet[0] |= 1 << 3 if err := func() error { if err := s.Jetton.Decode(d); err != nil { return err @@ -26855,13 +26139,12 @@ func (s *JettonTransferAction) Decode(d *jx.Decoder) error { } return nil }); err != nil { - return errors.Wrap(err, "decode JettonTransferAction") + return errors.Wrap(err, "decode JettonMintAction") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [2]uint8{ - 0b00011100, - 0b00000001, + 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. @@ -26873,8 +26156,8 @@ func (s *JettonTransferAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonTransferAction) { - name = jsonFieldsNameOfJettonTransferAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonMintAction) { + name = jsonFieldsNameOfJettonMintAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -26895,198 +26178,397 @@ func (s *JettonTransferAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonTransferAction) MarshalJSON() ([]byte, error) { +func (s *JettonMintAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonTransferAction) UnmarshalJSON(data []byte) error { +func (s *JettonMintAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonTransferPayload) Encode(e *jx.Encoder) { +func (s *JettonOperation) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonTransferPayload) encodeFields(e *jx.Encoder) { +func (s *JettonOperation) encodeFields(e *jx.Encoder) { { - if s.CustomPayload.Set { - e.FieldStart("custom_payload") - s.CustomPayload.Encode(e) - } + e.FieldStart("operation") + s.Operation.Encode(e) } { - if s.StateInit.Set { - e.FieldStart("state_init") - s.StateInit.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 jsonFieldsNameOfJettonTransferPayload = [2]string{ - 0: "custom_payload", - 1: "state_init", -} - -// Decode decodes JettonTransferPayload from json. -func (s *JettonTransferPayload) Decode(d *jx.Decoder) error { +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 JettonTransferPayload to 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 "custom_payload": + case "operation": + requiredBitSet[0] |= 1 << 0 if err := func() error { - s.CustomPayload.Reset() - if err := s.CustomPayload.Decode(d); err != nil { + if err := s.Operation.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"custom_payload\"") + return errors.Wrap(err, "decode field \"operation\"") } - case "state_init": + case "utime": + requiredBitSet[0] |= 1 << 1 if err := func() error { - s.StateInit.Reset() - if err := s.StateInit.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 \"state_init\"") + 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 JettonTransferPayload") + 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 *JettonTransferPayload) MarshalJSON() ([]byte, error) { +func (s *JettonOperation) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonTransferPayload) UnmarshalJSON(data []byte) error { +func (s *JettonOperation) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode encodes JettonVerificationType as json. -func (s JettonVerificationType) Encode(e *jx.Encoder) { +// Encode encodes JettonOperationOperation as json. +func (s JettonOperationOperation) Encode(e *jx.Encoder) { e.Str(string(s)) } -// Decode decodes JettonVerificationType from json. -func (s *JettonVerificationType) Decode(d *jx.Decoder) error { +// Decode decodes JettonOperationOperation from json. +func (s *JettonOperationOperation) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode JettonVerificationType to 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 JettonVerificationType(v) { - case JettonVerificationTypeWhitelist: - *s = JettonVerificationTypeWhitelist - case JettonVerificationTypeGraylist: - *s = JettonVerificationTypeGraylist - case JettonVerificationTypeBlacklist: - *s = JettonVerificationTypeBlacklist - case JettonVerificationTypeNone: - *s = JettonVerificationTypeNone + switch JettonOperationOperation(v) { + case JettonOperationOperationTransfer: + *s = JettonOperationOperationTransfer + case JettonOperationOperationMint: + *s = JettonOperationOperationMint + case JettonOperationOperationBurn: + *s = JettonOperationOperationBurn default: - *s = JettonVerificationType(v) + *s = JettonOperationOperation(v) } return nil } // MarshalJSON implements stdjson.Marshaler. -func (s JettonVerificationType) MarshalJSON() ([]byte, error) { +func (s JettonOperationOperation) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonVerificationType) UnmarshalJSON(data []byte) error { +func (s *JettonOperationOperation) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Jettons) Encode(e *jx.Encoder) { +func (s *JettonOperations) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Jettons) encodeFields(e *jx.Encoder) { +func (s *JettonOperations) encodeFields(e *jx.Encoder) { { - e.FieldStart("jettons") + e.FieldStart("operations") e.ArrStart() - for _, elem := range s.Jettons { + for _, elem := range s.Operations { elem.Encode(e) } e.ArrEnd() } + { + if s.NextFrom.Set { + e.FieldStart("next_from") + s.NextFrom.Encode(e) + } + } } -var jsonFieldsNameOfJettons = [1]string{ - 0: "jettons", +var jsonFieldsNameOfJettonOperations = [2]string{ + 0: "operations", + 1: "next_from", } -// Decode decodes Jettons from json. -func (s *Jettons) Decode(d *jx.Decoder) error { +// Decode decodes JettonOperations from json. +func (s *JettonOperations) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Jettons to 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 "jettons": + case "operations": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Jettons = make([]JettonInfo, 0) + s.Operations = make([]JettonOperation, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem JettonInfo + var elem JettonOperation if err := elem.Decode(d); err != nil { return err } - s.Jettons = append(s.Jettons, elem) + s.Operations = append(s.Operations, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"jettons\"") + 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 Jettons") + return errors.Wrap(err, "decode JettonOperations") } // Validate required fields. var failures []validate.FieldError @@ -27103,8 +26585,8 @@ func (s *Jettons) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettons) { - name = jsonFieldsNameOfJettons[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonOperations) { + name = jsonFieldsNameOfJettonOperations[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -27125,79 +26607,221 @@ func (s *Jettons) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Jettons) MarshalJSON() ([]byte, error) { +func (s *JettonOperations) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Jettons) UnmarshalJSON(data []byte) error { +func (s *JettonOperations) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *JettonsBalances) Encode(e *jx.Encoder) { +func (s *JettonPreview) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *JettonsBalances) encodeFields(e *jx.Encoder) { +func (s *JettonPreview) encodeFields(e *jx.Encoder) { { - e.FieldStart("balances") - e.ArrStart() - for _, elem := range s.Balances { - elem.Encode(e) + e.FieldStart("address") + e.Str(s.Address) + } + { + e.FieldStart("name") + e.Str(s.Name) + } + { + e.FieldStart("symbol") + e.Str(s.Symbol) + } + { + e.FieldStart("decimals") + e.Int(s.Decimals) + } + { + e.FieldStart("image") + e.Str(s.Image) + } + { + 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) + } + { + if s.ScaledUI.Set { + e.FieldStart("scaled_ui") + s.ScaledUI.Encode(e) + } + } + { + if s.Description.Set { + e.FieldStart("description") + s.Description.Encode(e) } - e.ArrEnd() } } -var jsonFieldsNameOfJettonsBalances = [1]string{ - 0: "balances", +var jsonFieldsNameOfJettonPreview = [10]string{ + 0: "address", + 1: "name", + 2: "symbol", + 3: "decimals", + 4: "image", + 5: "verification", + 6: "custom_payload_api_uri", + 7: "score", + 8: "scaled_ui", + 9: "description", } -// Decode decodes JettonsBalances from json. -func (s *JettonsBalances) Decode(d *jx.Decoder) error { +// Decode decodes JettonPreview from json. +func (s *JettonPreview) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode JettonsBalances to nil") + return errors.New("invalid: unable to decode JettonPreview 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 "balances": + case "address": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Balances = make([]JettonBalance, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem JettonBalance - if err := elem.Decode(d); err != nil { - return err - } - s.Balances = append(s.Balances, elem) - return nil - }); err != nil { + v, err := d.Str() + s.Address = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"balances\"") + 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 "symbol": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Symbol = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"symbol\"") + } + case "decimals": + requiredBitSet[0] |= 1 << 3 + 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 << 4 + 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 "verification": + requiredBitSet[0] |= 1 << 5 + 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 "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\"") + } + case "scaled_ui": + if err := func() error { + s.ScaledUI.Reset() + if err := s.ScaledUI.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"scaled_ui\"") + } + case "description": + if err := func() error { + s.Description.Reset() + if err := s.Description.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"description\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode JettonsBalances") + return errors.Wrap(err, "decode JettonPreview") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ - 0b00000001, + for i, mask := range [2]uint8{ + 0b10111111, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -27209,8 +26833,8 @@ func (s *JettonsBalances) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfJettonsBalances) { - name = jsonFieldsNameOfJettonsBalances[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonPreview) { + name = jsonFieldsNameOfJettonPreview[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -27231,104 +26855,94 @@ func (s *JettonsBalances) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *JettonsBalances) MarshalJSON() ([]byte, error) { +func (s *JettonPreview) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *JettonsBalances) UnmarshalJSON(data []byte) error { +func (s *JettonPreview) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *LiquidityDepositAction) Encode(e *jx.Encoder) { +func (s *JettonQuantity) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *LiquidityDepositAction) encodeFields(e *jx.Encoder) { +func (s *JettonQuantity) encodeFields(e *jx.Encoder) { { - e.FieldStart("protocol") - s.Protocol.Encode(e) + e.FieldStart("quantity") + e.Str(s.Quantity) } { - e.FieldStart("from") - s.From.Encode(e) + e.FieldStart("wallet_address") + s.WalletAddress.Encode(e) } { - e.FieldStart("tokens") - e.ArrStart() - for _, elem := range s.Tokens { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("jetton") + s.Jetton.Encode(e) } } -var jsonFieldsNameOfLiquidityDepositAction = [3]string{ - 0: "protocol", - 1: "from", - 2: "tokens", +var jsonFieldsNameOfJettonQuantity = [3]string{ + 0: "quantity", + 1: "wallet_address", + 2: "jetton", } -// Decode decodes LiquidityDepositAction from json. -func (s *LiquidityDepositAction) Decode(d *jx.Decoder) error { +// Decode decodes JettonQuantity from json. +func (s *JettonQuantity) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode LiquidityDepositAction to nil") + return errors.New("invalid: unable to decode JettonQuantity to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "protocol": + case "quantity": requiredBitSet[0] |= 1 << 0 if err := func() error { - if err := s.Protocol.Decode(d); err != nil { + v, err := d.Str() + s.Quantity = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"protocol\"") + return errors.Wrap(err, "decode field \"quantity\"") } - case "from": + case "wallet_address": requiredBitSet[0] |= 1 << 1 if err := func() error { - if err := s.From.Decode(d); err != nil { + if err := s.WalletAddress.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"from\"") + return errors.Wrap(err, "decode field \"wallet_address\"") } - case "tokens": + case "jetton": 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 { + if err := s.Jetton.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"tokens\"") + return errors.Wrap(err, "decode field \"jetton\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode LiquidityDepositAction") + return errors.Wrap(err, "decode JettonQuantity") } // Validate required fields. var failures []validate.FieldError @@ -27345,8 +26959,8 @@ func (s *LiquidityDepositAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfLiquidityDepositAction) { - name = jsonFieldsNameOfLiquidityDepositAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonQuantity) { + name = jsonFieldsNameOfJettonQuantity[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -27367,103 +26981,202 @@ func (s *LiquidityDepositAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *LiquidityDepositAction) MarshalJSON() ([]byte, error) { +func (s *JettonQuantity) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *LiquidityDepositAction) UnmarshalJSON(data []byte) error { +func (s *JettonQuantity) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *MarketTonRates) Encode(e *jx.Encoder) { +func (s *JettonSwapAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *MarketTonRates) encodeFields(e *jx.Encoder) { +func (s *JettonSwapAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("market") - e.Str(s.Market) + e.FieldStart("dex") + e.Str(s.Dex) } { - e.FieldStart("usd_price") - e.Float64(s.UsdPrice) + e.FieldStart("amount_in") + e.Str(s.AmountIn) } { - e.FieldStart("last_date_update") - e.Int64(s.LastDateUpdate) + e.FieldStart("amount_out") + e.Str(s.AmountOut) + } + { + if s.TonIn.Set { + e.FieldStart("ton_in") + s.TonIn.Encode(e) + } + } + { + if s.TonOut.Set { + e.FieldStart("ton_out") + s.TonOut.Encode(e) + } + } + { + e.FieldStart("user_wallet") + s.UserWallet.Encode(e) + } + { + e.FieldStart("router") + s.Router.Encode(e) + } + { + if s.JettonMasterIn.Set { + e.FieldStart("jetton_master_in") + s.JettonMasterIn.Encode(e) + } + } + { + if s.JettonMasterOut.Set { + e.FieldStart("jetton_master_out") + s.JettonMasterOut.Encode(e) + } } } -var jsonFieldsNameOfMarketTonRates = [3]string{ - 0: "market", - 1: "usd_price", - 2: "last_date_update", +var jsonFieldsNameOfJettonSwapAction = [9]string{ + 0: "dex", + 1: "amount_in", + 2: "amount_out", + 3: "ton_in", + 4: "ton_out", + 5: "user_wallet", + 6: "router", + 7: "jetton_master_in", + 8: "jetton_master_out", } -// Decode decodes MarketTonRates from json. -func (s *MarketTonRates) Decode(d *jx.Decoder) error { +// Decode decodes JettonSwapAction from json. +func (s *JettonSwapAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode MarketTonRates to nil") + return errors.New("invalid: unable to decode JettonSwapAction 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 "market": + case "dex": requiredBitSet[0] |= 1 << 0 if err := func() error { v, err := d.Str() - s.Market = string(v) + s.Dex = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"market\"") + return errors.Wrap(err, "decode field \"dex\"") } - case "usd_price": + case "amount_in": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Float64() - s.UsdPrice = float64(v) + v, err := d.Str() + s.AmountIn = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"usd_price\"") + return errors.Wrap(err, "decode field \"amount_in\"") } - case "last_date_update": + case "amount_out": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Int64() - s.LastDateUpdate = int64(v) + v, err := d.Str() + s.AmountOut = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"last_date_update\"") + return errors.Wrap(err, "decode field \"amount_out\"") + } + case "ton_in": + if err := func() error { + s.TonIn.Reset() + if err := s.TonIn.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ton_in\"") + } + case "ton_out": + if err := func() error { + s.TonOut.Reset() + if err := s.TonOut.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ton_out\"") + } + case "user_wallet": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + if err := s.UserWallet.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"user_wallet\"") + } + case "router": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + if err := s.Router.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"router\"") + } + case "jetton_master_in": + if err := func() error { + s.JettonMasterIn.Reset() + if err := s.JettonMasterIn.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"jetton_master_in\"") + } + case "jetton_master_out": + if err := func() error { + s.JettonMasterOut.Reset() + if err := s.JettonMasterOut.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"jetton_master_out\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode MarketTonRates") + return errors.Wrap(err, "decode JettonSwapAction") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ - 0b00000111, + for i, mask := range [2]uint8{ + 0b01100111, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -27475,8 +27188,8 @@ func (s *MarketTonRates) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfMarketTonRates) { - name = jsonFieldsNameOfMarketTonRates[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonSwapAction) { + name = jsonFieldsNameOfJettonSwapAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -27497,409 +27210,226 @@ func (s *MarketTonRates) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *MarketTonRates) MarshalJSON() ([]byte, error) { +func (s *JettonSwapAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *MarketTonRates) UnmarshalJSON(data []byte) error { +func (s *JettonSwapAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Message) Encode(e *jx.Encoder) { +func (s *JettonTransferAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Message) encodeFields(e *jx.Encoder) { +func (s *JettonTransferAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("msg_type") - s.MsgType.Encode(e) + if s.Sender.Set { + e.FieldStart("sender") + s.Sender.Encode(e) + } } { - e.FieldStart("created_lt") - e.Int64(s.CreatedLt) + if s.Recipient.Set { + e.FieldStart("recipient") + s.Recipient.Encode(e) + } } { - e.FieldStart("ihr_disabled") - e.Bool(s.IhrDisabled) - } - { - e.FieldStart("bounce") - e.Bool(s.Bounce) - } - { - e.FieldStart("bounced") - e.Bool(s.Bounced) - } - { - 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) - } - { - e.FieldStart("ihr_fee") - e.Int64(s.IhrFee) - } - { - if s.Destination.Set { - e.FieldStart("destination") - s.Destination.Encode(e) - } - } - { - if s.Source.Set { - e.FieldStart("source") - s.Source.Encode(e) - } - } - { - e.FieldStart("import_fee") - e.Int64(s.ImportFee) + e.FieldStart("senders_wallet") + e.Str(s.SendersWallet) } { - e.FieldStart("created_at") - e.Int64(s.CreatedAt) + e.FieldStart("recipients_wallet") + e.Str(s.RecipientsWallet) } { - if s.OpCode.Set { - e.FieldStart("op_code") - s.OpCode.Encode(e) - } + e.FieldStart("amount") + e.Str(s.Amount) } { - if s.Init.Set { - e.FieldStart("init") - s.Init.Encode(e) + if s.Comment.Set { + e.FieldStart("comment") + s.Comment.Encode(e) } } { - e.FieldStart("hash") - e.Str(s.Hash) - } - { - if s.RawBody.Set { - e.FieldStart("raw_body") - s.RawBody.Encode(e) + if s.EncryptedComment.Set { + e.FieldStart("encrypted_comment") + s.EncryptedComment.Encode(e) } } { - if s.DecodedOpName.Set { - e.FieldStart("decoded_op_name") - s.DecodedOpName.Encode(e) + if s.Refund.Set { + e.FieldStart("refund") + s.Refund.Encode(e) } } { - if len(s.DecodedBody) != 0 { - e.FieldStart("decoded_body") - e.Raw(s.DecodedBody) - } + e.FieldStart("jetton") + s.Jetton.Encode(e) } } -var jsonFieldsNameOfMessage = [19]string{ - 0: "msg_type", - 1: "created_lt", - 2: "ihr_disabled", - 3: "bounce", - 4: "bounced", - 5: "value", - 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", +var jsonFieldsNameOfJettonTransferAction = [9]string{ + 0: "sender", + 1: "recipient", + 2: "senders_wallet", + 3: "recipients_wallet", + 4: "amount", + 5: "comment", + 6: "encrypted_comment", + 7: "refund", + 8: "jetton", } -// Decode decodes Message from json. -func (s *Message) Decode(d *jx.Decoder) error { +// Decode decodes JettonTransferAction from json. +func (s *JettonTransferAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Message to nil") + return errors.New("invalid: unable to decode JettonTransferAction to nil") } - var requiredBitSet [3]uint8 + var requiredBitSet [2]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "msg_type": - requiredBitSet[0] |= 1 << 0 + case "sender": if err := func() error { - if err := s.MsgType.Decode(d); err != nil { + s.Sender.Reset() + if err := s.Sender.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"msg_type\"") + return errors.Wrap(err, "decode field \"sender\"") } - case "created_lt": - requiredBitSet[0] |= 1 << 1 + case "recipient": if err := func() error { - v, err := d.Int64() - s.CreatedLt = int64(v) - if err != nil { + s.Recipient.Reset() + if err := s.Recipient.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"created_lt\"") + return errors.Wrap(err, "decode field \"recipient\"") } - case "ihr_disabled": + case "senders_wallet": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Bool() - s.IhrDisabled = bool(v) + v, err := d.Str() + s.SendersWallet = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ihr_disabled\"") + return errors.Wrap(err, "decode field \"senders_wallet\"") } - case "bounce": + case "recipients_wallet": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Bool() - s.Bounce = bool(v) + v, err := d.Str() + s.RecipientsWallet = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"bounce\"") + return errors.Wrap(err, "decode field \"recipients_wallet\"") } - case "bounced": + case "amount": requiredBitSet[0] |= 1 << 4 if err := func() error { - v, err := d.Bool() - s.Bounced = bool(v) + v, err := d.Str() + s.Amount = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"bounced\"") + return errors.Wrap(err, "decode field \"amount\"") } - case "value": - requiredBitSet[0] |= 1 << 5 + case "comment": if err := func() error { - v, err := d.Int64() - s.Value = 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 \"value\"") + return errors.Wrap(err, "decode field \"comment\"") } - case "value_extra": + case "encrypted_comment": 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 { + s.EncryptedComment.Reset() + if err := s.EncryptedComment.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"value_extra\"") + return errors.Wrap(err, "decode field \"encrypted_comment\"") } - case "fwd_fee": - requiredBitSet[0] |= 1 << 7 + case "refund": if err := func() error { - v, err := d.Int64() - s.FwdFee = int64(v) - if err != nil { + s.Refund.Reset() + if err := s.Refund.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"fwd_fee\"") + return errors.Wrap(err, "decode field \"refund\"") } - case "ihr_fee": + case "jetton": requiredBitSet[1] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.IhrFee = int64(v) - if err != nil { + if err := s.Jetton.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"ihr_fee\"") + return errors.Wrap(err, "decode field \"jetton\"") } - case "destination": - if err := func() error { - s.Destination.Reset() - if err := s.Destination.Decode(d); err != nil { - return err + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode JettonTransferAction") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b00011100, + 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(jsonFieldsNameOfJettonTransferAction) { + name = jsonFieldsNameOfJettonTransferAction[fieldIdx] + } else { + name = strconv.Itoa(fieldIdx) } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"destination\"") - } - 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 "import_fee": - requiredBitSet[1] |= 1 << 3 - if err := func() error { - v, err := d.Int64() - s.ImportFee = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"import_fee\"") - } - case "created_at": - requiredBitSet[1] |= 1 << 4 - if err := func() error { - v, err := d.Int64() - s.CreatedAt = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"created_at\"") - } - case "op_code": - if err := func() error { - s.OpCode.Reset() - if err := s.OpCode.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"op_code\"") - } - case "init": - if err := func() error { - s.Init.Reset() - if err := s.Init.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"init\"") - } - case "hash": - requiredBitSet[1] |= 1 << 7 - 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 "raw_body": - if err := func() error { - s.RawBody.Reset() - if err := s.RawBody.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"raw_body\"") - } - case "decoded_op_name": - if err := func() error { - s.DecodedOpName.Reset() - if err := s.DecodedOpName.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"decoded_op_name\"") - } - case "decoded_body": - if err := func() error { - v, err := d.RawAppend(nil) - s.DecodedBody = jx.Raw(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"decoded_body\"") - } - default: - return d.Skip() - } - return nil - }); err != nil { - return errors.Wrap(err, "decode Message") - } - // Validate required fields. - var failures []validate.FieldError - for i, mask := range [3]uint8{ - 0b10111111, - 0b10011001, - 0b00000000, - } { - 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(jsonFieldsNameOfMessage) { - name = jsonFieldsNameOfMessage[fieldIdx] - } else { - name = strconv.Itoa(fieldIdx) - } - failures = append(failures, validate.FieldError{ - Name: name, - Error: validate.ErrFieldRequired, - }) - // Reset bit. - result &^= 1 << bitIdx + failures = append(failures, validate.FieldError{ + Name: name, + Error: validate.ErrFieldRequired, + }) + // Reset bit. + result &^= 1 << bitIdx } } } @@ -27911,247 +27441,198 @@ func (s *Message) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Message) MarshalJSON() ([]byte, error) { +func (s *JettonTransferAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Message) UnmarshalJSON(data []byte) error { +func (s *JettonTransferAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *MessageConsequences) Encode(e *jx.Encoder) { +func (s *JettonTransferPayload) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *MessageConsequences) encodeFields(e *jx.Encoder) { - { - e.FieldStart("trace") - s.Trace.Encode(e) - } +func (s *JettonTransferPayload) encodeFields(e *jx.Encoder) { { - e.FieldStart("risk") - s.Risk.Encode(e) + if s.CustomPayload.Set { + e.FieldStart("custom_payload") + s.CustomPayload.Encode(e) + } } { - e.FieldStart("event") - s.Event.Encode(e) + if s.StateInit.Set { + e.FieldStart("state_init") + s.StateInit.Encode(e) + } } } -var jsonFieldsNameOfMessageConsequences = [3]string{ - 0: "trace", - 1: "risk", - 2: "event", +var jsonFieldsNameOfJettonTransferPayload = [2]string{ + 0: "custom_payload", + 1: "state_init", } -// Decode decodes MessageConsequences from json. -func (s *MessageConsequences) Decode(d *jx.Decoder) error { +// Decode decodes JettonTransferPayload from json. +func (s *JettonTransferPayload) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode MessageConsequences to nil") + return errors.New("invalid: unable to decode JettonTransferPayload to nil") } - var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "trace": - requiredBitSet[0] |= 1 << 0 - if err := func() error { - if err := s.Trace.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"trace\"") - } - case "risk": - requiredBitSet[0] |= 1 << 1 + case "custom_payload": if err := func() error { - if err := s.Risk.Decode(d); err != nil { + s.CustomPayload.Reset() + if err := s.CustomPayload.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"risk\"") + return errors.Wrap(err, "decode field \"custom_payload\"") } - case "event": - requiredBitSet[0] |= 1 << 2 + case "state_init": if err := func() error { - if err := s.Event.Decode(d); err != nil { + s.StateInit.Reset() + if err := s.StateInit.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"event\"") + return errors.Wrap(err, "decode field \"state_init\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode MessageConsequences") - } - // 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(jsonFieldsNameOfMessageConsequences) { - name = jsonFieldsNameOfMessageConsequences[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 JettonTransferPayload") } return nil } // MarshalJSON implements stdjson.Marshaler. -func (s *MessageConsequences) MarshalJSON() ([]byte, error) { +func (s *JettonTransferPayload) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *MessageConsequences) UnmarshalJSON(data []byte) error { +func (s *JettonTransferPayload) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode encodes MessageMsgType as json. -func (s MessageMsgType) Encode(e *jx.Encoder) { +// Encode encodes JettonVerificationType as json. +func (s JettonVerificationType) Encode(e *jx.Encoder) { e.Str(string(s)) } -// Decode decodes MessageMsgType from json. -func (s *MessageMsgType) Decode(d *jx.Decoder) error { +// Decode decodes JettonVerificationType from json. +func (s *JettonVerificationType) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode MessageMsgType to nil") + return errors.New("invalid: unable to decode JettonVerificationType to nil") } v, err := d.StrBytes() if err != nil { return err } // Try to use constant string. - switch MessageMsgType(v) { - case MessageMsgTypeIntMsg: - *s = MessageMsgTypeIntMsg - case MessageMsgTypeExtInMsg: - *s = MessageMsgTypeExtInMsg - case MessageMsgTypeExtOutMsg: - *s = MessageMsgTypeExtOutMsg + switch JettonVerificationType(v) { + case JettonVerificationTypeWhitelist: + *s = JettonVerificationTypeWhitelist + case JettonVerificationTypeGraylist: + *s = JettonVerificationTypeGraylist + case JettonVerificationTypeBlacklist: + *s = JettonVerificationTypeBlacklist + case JettonVerificationTypeNone: + *s = JettonVerificationTypeNone default: - *s = MessageMsgType(v) + *s = JettonVerificationType(v) } return nil } // MarshalJSON implements stdjson.Marshaler. -func (s MessageMsgType) MarshalJSON() ([]byte, error) { +func (s JettonVerificationType) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *MessageMsgType) UnmarshalJSON(data []byte) error { +func (s *JettonVerificationType) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Metadata) Encode(e *jx.Encoder) { +func (s *Jettons) 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) - } +func (s *Jettons) encodeFields(e *jx.Encoder) { { - if s.DecryptionKey.Set { - e.FieldStart("decryption_key") - s.DecryptionKey.Encode(e) + e.FieldStart("jettons") + e.ArrStart() + for _, elem := range s.Jettons { + elem.Encode(e) } + e.ArrEnd() } } -var jsonFieldsNameOfMetadata = [2]string{ - 0: "encrypted_binary", - 1: "decryption_key", +var jsonFieldsNameOfJettons = [1]string{ + 0: "jettons", } -// Decode decodes Metadata from json. -func (s *Metadata) Decode(d *jx.Decoder) error { +// Decode decodes Jettons from json. +func (s *Jettons) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Metadata to nil") + return errors.New("invalid: unable to decode Jettons to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "encrypted_binary": + case "jettons": 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 { + s.Jettons = make([]JettonInfo, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem JettonInfo + 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 \"decryption_key\"") + return errors.Wrap(err, "decode field \"jettons\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Metadata") + return errors.Wrap(err, "decode Jettons") } // Validate required fields. var failures []validate.FieldError @@ -28168,8 +27649,8 @@ func (s *Metadata) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfMetadata) { - name = jsonFieldsNameOfMetadata[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettons) { + name = jsonFieldsNameOfJettons[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -28190,86 +27671,79 @@ func (s *Metadata) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Metadata) MarshalJSON() ([]byte, error) { +func (s *Jettons) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Metadata) UnmarshalJSON(data []byte) error { +func (s *Jettons) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Method) Encode(e *jx.Encoder) { +func (s *JettonsBalances) 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) - } +func (s *JettonsBalances) encodeFields(e *jx.Encoder) { { - e.FieldStart("method") - e.Str(s.Method) + e.FieldStart("balances") + e.ArrStart() + for _, elem := range s.Balances { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfMethod = [2]string{ - 0: "id", - 1: "method", +var jsonFieldsNameOfJettonsBalances = [1]string{ + 0: "balances", } -// Decode decodes Method from json. -func (s *Method) Decode(d *jx.Decoder) error { +// Decode decodes JettonsBalances from json. +func (s *JettonsBalances) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Method to nil") + return errors.New("invalid: unable to decode JettonsBalances to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "id": + case "balances": 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 { + s.Balances = make([]JettonBalance, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem JettonBalance + if err := elem.Decode(d); err != nil { + return err + } + s.Balances = append(s.Balances, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"method\"") + return errors.Wrap(err, "decode field \"balances\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Method") + return errors.Wrap(err, "decode JettonsBalances") } // 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. @@ -28281,8 +27755,8 @@ func (s *Method) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfMethod) { - name = jsonFieldsNameOfMethod[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfJettonsBalances) { + name = jsonFieldsNameOfJettonsBalances[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -28303,126 +27777,104 @@ func (s *Method) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Method) MarshalJSON() ([]byte, error) { +func (s *JettonsBalances) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Method) UnmarshalJSON(data []byte) error { +func (s *JettonsBalances) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *MethodExecutionResult) Encode(e *jx.Encoder) { +func (s *LiquidityDepositAction) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *MethodExecutionResult) encodeFields(e *jx.Encoder) { +func (s *LiquidityDepositAction) encodeFields(e *jx.Encoder) { { - e.FieldStart("success") - e.Bool(s.Success) + e.FieldStart("protocol") + s.Protocol.Encode(e) } { - e.FieldStart("exit_code") - e.Int(s.ExitCode) + e.FieldStart("from") + s.From.Encode(e) } { - e.FieldStart("stack") + e.FieldStart("tokens") e.ArrStart() - for _, elem := range s.Stack { + for _, elem := range s.Tokens { elem.Encode(e) } e.ArrEnd() } - { - if len(s.Decoded) != 0 { - e.FieldStart("decoded") - e.Raw(s.Decoded) - } - } } -var jsonFieldsNameOfMethodExecutionResult = [4]string{ - 0: "success", - 1: "exit_code", - 2: "stack", - 3: "decoded", +var jsonFieldsNameOfLiquidityDepositAction = [3]string{ + 0: "protocol", + 1: "from", + 2: "tokens", } -// Decode decodes MethodExecutionResult from json. -func (s *MethodExecutionResult) Decode(d *jx.Decoder) error { +// Decode decodes LiquidityDepositAction from json. +func (s *LiquidityDepositAction) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode MethodExecutionResult to 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 "success": + case "protocol": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Bool() - s.Success = bool(v) - if err != nil { + if err := s.Protocol.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"success\"") + return errors.Wrap(err, "decode field \"protocol\"") } - case "exit_code": + case "from": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int() - s.ExitCode = int(v) - if err != nil { + if err := s.From.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"exit_code\"") + return errors.Wrap(err, "decode field \"from\"") } - case "stack": + case "tokens": requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Stack = make([]TvmStackRecord, 0) + s.Tokens = make([]VaultDepositInfo, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem TvmStackRecord + var elem VaultDepositInfo if err := elem.Decode(d); err != nil { return err } - s.Stack = append(s.Stack, elem) + s.Tokens = append(s.Tokens, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"stack\"") - } - case "decoded": - if err := func() error { - v, err := d.RawAppend(nil) - s.Decoded = jx.Raw(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"decoded\"") + return errors.Wrap(err, "decode field \"tokens\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode MethodExecutionResult") + return errors.Wrap(err, "decode LiquidityDepositAction") } // Validate required fields. var failures []validate.FieldError @@ -28439,8 +27891,8 @@ func (s *MethodExecutionResult) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfMethodExecutionResult) { - name = jsonFieldsNameOfMethodExecutionResult[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfLiquidityDepositAction) { + name = jsonFieldsNameOfLiquidityDepositAction[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -28461,239 +27913,102 @@ func (s *MethodExecutionResult) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *MethodExecutionResult) MarshalJSON() ([]byte, error) { +func (s *LiquidityDepositAction) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *MethodExecutionResult) UnmarshalJSON(data []byte) error { +func (s *LiquidityDepositAction) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *MisbehaviourPunishmentConfig) Encode(e *jx.Encoder) { +func (s *MarketTonRates) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *MisbehaviourPunishmentConfig) encodeFields(e *jx.Encoder) { - { - e.FieldStart("default_flat_fine") - e.Int64(s.DefaultFlatFine) - } +func (s *MarketTonRates) encodeFields(e *jx.Encoder) { { - e.FieldStart("default_proportional_fine") - e.Int64(s.DefaultProportionalFine) + e.FieldStart("market") + e.Str(s.Market) } { - e.FieldStart("severity_flat_mult") - e.Int(s.SeverityFlatMult) + e.FieldStart("usd_price") + e.Float64(s.UsdPrice) } { - e.FieldStart("severity_proportional_mult") - e.Int(s.SeverityProportionalMult) + e.FieldStart("last_date_update") + e.Int64(s.LastDateUpdate) } - { - e.FieldStart("unpunishable_interval") - e.Int(s.UnpunishableInterval) +} + +var jsonFieldsNameOfMarketTonRates = [3]string{ + 0: "market", + 1: "usd_price", + 2: "last_date_update", +} + +// Decode decodes MarketTonRates from json. +func (s *MarketTonRates) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode MarketTonRates to nil") } - { - e.FieldStart("long_interval") - e.Int(s.LongInterval) - } - { - e.FieldStart("long_flat_mult") - e.Int(s.LongFlatMult) - } - { - e.FieldStart("long_proportional_mult") - e.Int(s.LongProportionalMult) - } - { - e.FieldStart("medium_interval") - e.Int(s.MediumInterval) - } - { - e.FieldStart("medium_flat_mult") - e.Int(s.MediumFlatMult) - } - { - e.FieldStart("medium_proportional_mult") - e.Int(s.MediumProportionalMult) - } -} - -var jsonFieldsNameOfMisbehaviourPunishmentConfig = [11]string{ - 0: "default_flat_fine", - 1: "default_proportional_fine", - 2: "severity_flat_mult", - 3: "severity_proportional_mult", - 4: "unpunishable_interval", - 5: "long_interval", - 6: "long_flat_mult", - 7: "long_proportional_mult", - 8: "medium_interval", - 9: "medium_flat_mult", - 10: "medium_proportional_mult", -} - -// Decode decodes MisbehaviourPunishmentConfig from json. -func (s *MisbehaviourPunishmentConfig) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode MisbehaviourPunishmentConfig 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 "default_flat_fine": + case "market": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int64() - s.DefaultFlatFine = int64(v) + v, err := d.Str() + s.Market = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"default_flat_fine\"") + return errors.Wrap(err, "decode field \"market\"") } - case "default_proportional_fine": + case "usd_price": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int64() - s.DefaultProportionalFine = int64(v) + v, err := d.Float64() + s.UsdPrice = float64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"default_proportional_fine\"") + return errors.Wrap(err, "decode field \"usd_price\"") } - case "severity_flat_mult": + case "last_date_update": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Int() - s.SeverityFlatMult = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"severity_flat_mult\"") - } - case "severity_proportional_mult": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Int() - s.SeverityProportionalMult = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"severity_proportional_mult\"") - } - case "unpunishable_interval": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Int() - s.UnpunishableInterval = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"unpunishable_interval\"") - } - case "long_interval": - requiredBitSet[0] |= 1 << 5 - if err := func() error { - v, err := d.Int() - s.LongInterval = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"long_interval\"") - } - case "long_flat_mult": - requiredBitSet[0] |= 1 << 6 - if err := func() error { - v, err := d.Int() - s.LongFlatMult = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"long_flat_mult\"") - } - case "long_proportional_mult": - requiredBitSet[0] |= 1 << 7 - if err := func() error { - v, err := d.Int() - s.LongProportionalMult = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"long_proportional_mult\"") - } - case "medium_interval": - requiredBitSet[1] |= 1 << 0 - if err := func() error { - v, err := d.Int() - s.MediumInterval = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"medium_interval\"") - } - case "medium_flat_mult": - requiredBitSet[1] |= 1 << 1 - if err := func() error { - v, err := d.Int() - s.MediumFlatMult = int(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"medium_flat_mult\"") - } - case "medium_proportional_mult": - requiredBitSet[1] |= 1 << 2 - if err := func() error { - v, err := d.Int() - s.MediumProportionalMult = int(v) + v, err := d.Int64() + s.LastDateUpdate = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"medium_proportional_mult\"") + return errors.Wrap(err, "decode field \"last_date_update\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode MisbehaviourPunishmentConfig") + return errors.Wrap(err, "decode MarketTonRates") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [2]uint8{ - 0b11111111, + for i, mask := range [1]uint8{ 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { @@ -28706,8 +28021,8 @@ func (s *MisbehaviourPunishmentConfig) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfMisbehaviourPunishmentConfig) { - name = jsonFieldsNameOfMisbehaviourPunishmentConfig[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfMarketTonRates) { + name = jsonFieldsNameOfMarketTonRates[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -28728,369 +28043,387 @@ func (s *MisbehaviourPunishmentConfig) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *MisbehaviourPunishmentConfig) MarshalJSON() ([]byte, error) { +func (s *MarketTonRates) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *MisbehaviourPunishmentConfig) UnmarshalJSON(data []byte) error { +func (s *MarketTonRates) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *MsgForwardPrices) Encode(e *jx.Encoder) { +func (s *Message) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *MsgForwardPrices) encodeFields(e *jx.Encoder) { +func (s *Message) encodeFields(e *jx.Encoder) { { - e.FieldStart("lump_price") - e.Int64(s.LumpPrice) + e.FieldStart("msg_type") + s.MsgType.Encode(e) } { - e.FieldStart("bit_price") - e.Int64(s.BitPrice) + e.FieldStart("created_lt") + e.Int64(s.CreatedLt) } { - e.FieldStart("cell_price") - e.Int64(s.CellPrice) + e.FieldStart("ihr_disabled") + e.Bool(s.IhrDisabled) } { - e.FieldStart("ihr_price_factor") - e.Int64(s.IhrPriceFactor) + e.FieldStart("bounce") + e.Bool(s.Bounce) } { - e.FieldStart("first_frac") - e.Int64(s.FirstFrac) + e.FieldStart("bounced") + e.Bool(s.Bounced) } { - e.FieldStart("next_frac") - e.Int64(s.NextFrac) - } -} - -var jsonFieldsNameOfMsgForwardPrices = [6]string{ - 0: "lump_price", - 1: "bit_price", - 2: "cell_price", - 3: "ihr_price_factor", - 4: "first_frac", - 5: "next_frac", -} - -// Decode decodes MsgForwardPrices from json. -func (s *MsgForwardPrices) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode MsgForwardPrices to nil") + e.FieldStart("value") + e.Int64(s.Value) } - var requiredBitSet [1]uint8 - - if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { - switch string(k) { - case "lump_price": - requiredBitSet[0] |= 1 << 0 - if err := func() error { - v, err := d.Int64() - s.LumpPrice = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"lump_price\"") - } - case "bit_price": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Int64() - s.BitPrice = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"bit_price\"") + { + if s.ValueExtra != nil { + e.FieldStart("value_extra") + e.ArrStart() + for _, elem := range s.ValueExtra { + elem.Encode(e) } - case "cell_price": - requiredBitSet[0] |= 1 << 2 - if err := func() error { - v, err := d.Int64() - s.CellPrice = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"cell_price\"") - } - case "ihr_price_factor": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Int64() - s.IhrPriceFactor = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"ihr_price_factor\"") - } - case "first_frac": - requiredBitSet[0] |= 1 << 4 - if err := func() error { - v, err := d.Int64() - s.FirstFrac = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"first_frac\"") - } - case "next_frac": - requiredBitSet[0] |= 1 << 5 - if err := func() error { - v, err := d.Int64() - s.NextFrac = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"next_frac\"") - } - default: - return d.Skip() + e.ArrEnd() } - return nil - }); err != nil { - return errors.Wrap(err, "decode MsgForwardPrices") } - // Validate required fields. - var failures []validate.FieldError - 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. - // - // 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(jsonFieldsNameOfMsgForwardPrices) { - name = jsonFieldsNameOfMsgForwardPrices[fieldIdx] - } else { - name = strconv.Itoa(fieldIdx) - } - failures = append(failures, validate.FieldError{ - Name: name, - Error: validate.ErrFieldRequired, - }) - // Reset bit. - result &^= 1 << bitIdx - } + { + e.FieldStart("fwd_fee") + e.Int64(s.FwdFee) + } + { + e.FieldStart("ihr_fee") + e.Int64(s.IhrFee) + } + { + if s.Destination.Set { + e.FieldStart("destination") + s.Destination.Encode(e) } } - if len(failures) > 0 { - return &validate.Error{Fields: failures} + { + if s.Source.Set { + e.FieldStart("source") + s.Source.Encode(e) + } } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s *MsgForwardPrices) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *MsgForwardPrices) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s *Multisig) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *Multisig) encodeFields(e *jx.Encoder) { { - e.FieldStart("address") - e.Str(s.Address) + e.FieldStart("import_fee") + e.Int64(s.ImportFee) } { - e.FieldStart("seqno") - e.Str(s.Seqno) + e.FieldStart("created_at") + e.Int64(s.CreatedAt) } { - e.FieldStart("threshold") - e.Int32(s.Threshold) + if s.OpCode.Set { + e.FieldStart("op_code") + s.OpCode.Encode(e) + } } { - e.FieldStart("signers") - e.ArrStart() - for _, elem := range s.Signers { - e.Str(elem) + if s.Init.Set { + e.FieldStart("init") + s.Init.Encode(e) } - e.ArrEnd() } { - e.FieldStart("proposers") - e.ArrStart() - for _, elem := range s.Proposers { - e.Str(elem) + e.FieldStart("hash") + e.Str(s.Hash) + } + { + if s.RawBody.Set { + e.FieldStart("raw_body") + s.RawBody.Encode(e) } - e.ArrEnd() } { - e.FieldStart("orders") - e.ArrStart() - for _, elem := range s.Orders { - elem.Encode(e) + if s.DecodedOpName.Set { + e.FieldStart("decoded_op_name") + s.DecodedOpName.Encode(e) + } + } + { + if len(s.DecodedBody) != 0 { + e.FieldStart("decoded_body") + e.Raw(s.DecodedBody) } - e.ArrEnd() } } -var jsonFieldsNameOfMultisig = [6]string{ - 0: "address", - 1: "seqno", - 2: "threshold", - 3: "signers", - 4: "proposers", - 5: "orders", +var jsonFieldsNameOfMessage = [19]string{ + 0: "msg_type", + 1: "created_lt", + 2: "ihr_disabled", + 3: "bounce", + 4: "bounced", + 5: "value", + 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 Multisig from json. -func (s *Multisig) Decode(d *jx.Decoder) error { +// Decode decodes Message from json. +func (s *Message) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Multisig to nil") + return errors.New("invalid: unable to decode Message to nil") } - var requiredBitSet [1]uint8 + var requiredBitSet [3]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "msg_type": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Address = string(v) - if err != nil { + if err := s.MsgType.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") + return errors.Wrap(err, "decode field \"msg_type\"") } - case "seqno": + case "created_lt": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.Seqno = string(v) + v, err := d.Int64() + s.CreatedLt = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"seqno\"") + return errors.Wrap(err, "decode field \"created_lt\"") } - case "threshold": + case "ihr_disabled": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Int32() - s.Threshold = int32(v) + v, err := d.Bool() + s.IhrDisabled = bool(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"threshold\"") + return errors.Wrap(err, "decode field \"ihr_disabled\"") } - case "signers": + case "bounce": requiredBitSet[0] |= 1 << 3 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 { + v, err := d.Bool() + s.Bounce = bool(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"signers\"") + return errors.Wrap(err, "decode field \"bounce\"") } - case "proposers": + case "bounced": requiredBitSet[0] |= 1 << 4 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 { + v, err := d.Bool() + s.Bounced = bool(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"proposers\"") + return errors.Wrap(err, "decode field \"bounced\"") } - case "orders": + case "value": requiredBitSet[0] |= 1 << 5 if err := func() error { - s.Orders = make([]MultisigOrder, 0) + v, err := d.Int64() + s.Value = int64(v) + if err != nil { + return err + } + return nil + }(); 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 MultisigOrder + var elem ExtraCurrency if err := elem.Decode(d); err != nil { return err } - s.Orders = append(s.Orders, elem) + s.ValueExtra = append(s.ValueExtra, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"orders\"") + return errors.Wrap(err, "decode field \"value_extra\"") + } + case "fwd_fee": + requiredBitSet[0] |= 1 << 7 + if err := func() error { + v, err := d.Int64() + s.FwdFee = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"fwd_fee\"") + } + case "ihr_fee": + requiredBitSet[1] |= 1 << 0 + if err := func() error { + v, err := d.Int64() + s.IhrFee = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ihr_fee\"") + } + 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 "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 "import_fee": + requiredBitSet[1] |= 1 << 3 + if err := func() error { + v, err := d.Int64() + s.ImportFee = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"import_fee\"") + } + case "created_at": + requiredBitSet[1] |= 1 << 4 + if err := func() error { + v, err := d.Int64() + s.CreatedAt = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"created_at\"") + } + case "op_code": + if err := func() error { + s.OpCode.Reset() + if err := s.OpCode.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"op_code\"") + } + case "init": + if err := func() error { + s.Init.Reset() + if err := s.Init.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"init\"") + } + case "hash": + requiredBitSet[1] |= 1 << 7 + 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 "raw_body": + if err := func() error { + s.RawBody.Reset() + if err := s.RawBody.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"raw_body\"") + } + case "decoded_op_name": + if err := func() error { + s.DecodedOpName.Reset() + if err := s.DecodedOpName.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"decoded_op_name\"") + } + case "decoded_body": + if err := func() error { + v, err := d.RawAppend(nil) + s.DecodedBody = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"decoded_body\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode Multisig") + return errors.Wrap(err, "decode Message") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ - 0b00111111, + for i, mask := range [3]uint8{ + 0b10111111, + 0b10011001, + 0b00000000, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -29102,8 +28435,8 @@ func (s *Multisig) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfMultisig) { - name = jsonFieldsNameOfMultisig[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfMessage) { + name = jsonFieldsNameOfMessage[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -29124,205 +28457,68 @@ func (s *Multisig) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Multisig) MarshalJSON() ([]byte, error) { +func (s *Message) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Multisig) UnmarshalJSON(data []byte) error { +func (s *Message) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *MultisigOrder) Encode(e *jx.Encoder) { +func (s *MessageConsequences) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *MultisigOrder) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } - { - e.FieldStart("order_seqno") - e.Str(s.OrderSeqno) - } - { - e.FieldStart("threshold") - e.Int32(s.Threshold) - } - { - e.FieldStart("sent_for_execution") - e.Bool(s.SentForExecution) - } - { - e.FieldStart("signers") - e.ArrStart() - for _, elem := range s.Signers { - e.Str(elem) - } - e.ArrEnd() - } - { - e.FieldStart("approvals_num") - e.Int32(s.ApprovalsNum) - } +func (s *MessageConsequences) encodeFields(e *jx.Encoder) { { - e.FieldStart("expiration_date") - e.Int64(s.ExpirationDate) + e.FieldStart("trace") + s.Trace.Encode(e) } { 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) - } + e.FieldStart("event") + s.Event.Encode(e) } } -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", +var jsonFieldsNameOfMessageConsequences = [3]string{ + 0: "trace", + 1: "risk", + 2: "event", } -// Decode decodes MultisigOrder from json. -func (s *MultisigOrder) Decode(d *jx.Decoder) error { +// Decode decodes MessageConsequences from json. +func (s *MessageConsequences) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode MultisigOrder to nil") + return errors.New("invalid: unable to decode MessageConsequences 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 "trace": 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 "order_seqno": - requiredBitSet[0] |= 1 << 1 - if err := func() error { - v, err := d.Str() - s.OrderSeqno = string(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"order_seqno\"") - } - case "threshold": - requiredBitSet[0] |= 1 << 2 - 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 "sent_for_execution": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Bool() - s.SentForExecution = bool(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"sent_for_execution\"") - } - case "signers": - requiredBitSet[0] |= 1 << 4 - 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 "approvals_num": - requiredBitSet[0] |= 1 << 5 - if err := func() error { - v, err := d.Int32() - s.ApprovalsNum = int32(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"approvals_num\"") - } - case "expiration_date": - requiredBitSet[0] |= 1 << 6 - if err := func() error { - v, err := d.Int64() - s.ExpirationDate = int64(v) - if err != nil { + if err := s.Trace.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"expiration_date\"") + return errors.Wrap(err, "decode field \"trace\"") } case "risk": - requiredBitSet[0] |= 1 << 7 + requiredBitSet[0] |= 1 << 1 if err := func() error { if err := s.Risk.Decode(d); err != nil { return err @@ -29331,71 +28527,26 @@ 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": + case "event": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.ChangingParameters.Reset() - if err := s.ChangingParameters.Decode(d); err != nil { + if err := s.Event.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"changing_parameters\"") + return errors.Wrap(err, "decode field \"event\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode MultisigOrder") + return errors.Wrap(err, "decode MessageConsequences") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [2]uint8{ - 0b11111111, + for i, mask := range [1]uint8{ 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { @@ -29408,8 +28559,8 @@ func (s *MultisigOrder) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfMultisigOrder) { - name = jsonFieldsNameOfMultisigOrder[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfMessageConsequences) { + name = jsonFieldsNameOfMessageConsequences[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -29430,127 +28581,128 @@ func (s *MultisigOrder) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *MultisigOrder) MarshalJSON() ([]byte, error) { +func (s *MessageConsequences) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *MultisigOrder) UnmarshalJSON(data []byte) error { +func (s *MessageConsequences) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes MessageMsgType as json. +func (s MessageMsgType) Encode(e *jx.Encoder) { + e.Str(string(s)) +} + +// Decode decodes MessageMsgType from json. +func (s *MessageMsgType) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode MessageMsgType to nil") + } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch MessageMsgType(v) { + case MessageMsgTypeIntMsg: + *s = MessageMsgTypeIntMsg + case MessageMsgTypeExtInMsg: + *s = MessageMsgTypeExtInMsg + case MessageMsgTypeExtOutMsg: + *s = MessageMsgTypeExtOutMsg + default: + *s = MessageMsgType(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s MessageMsgType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *MessageMsgType) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *MultisigOrderChangingParameters) Encode(e *jx.Encoder) { +func (s *Metadata) 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) - } +func (s *Metadata) encodeFields(e *jx.Encoder) { { - e.FieldStart("signers") - e.ArrStart() - for _, elem := range s.Signers { - e.Str(elem) - } - e.ArrEnd() + e.FieldStart("encrypted_binary") + e.Str(s.EncryptedBinary) } { - e.FieldStart("proposers") - e.ArrStart() - for _, elem := range s.Proposers { - e.Str(elem) + if s.DecryptionKey.Set { + e.FieldStart("decryption_key") + s.DecryptionKey.Encode(e) } - e.ArrEnd() } } -var jsonFieldsNameOfMultisigOrderChangingParameters = [3]string{ - 0: "threshold", - 1: "signers", - 2: "proposers", +var jsonFieldsNameOfMetadata = [2]string{ + 0: "encrypted_binary", + 1: "decryption_key", } -// Decode decodes MultisigOrderChangingParameters from json. -func (s *MultisigOrderChangingParameters) Decode(d *jx.Decoder) error { +// Decode decodes Metadata from json. +func (s *Metadata) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode MultisigOrderChangingParameters to 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 "threshold": + case "encrypted_binary": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Int32() - s.Threshold = int32(v) + v, err := d.Str() + s.EncryptedBinary = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"threshold\"") + return errors.Wrap(err, "decode field \"encrypted_binary\"") } - case "signers": - requiredBitSet[0] |= 1 << 1 + case "decryption_key": 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 { + s.DecryptionKey.Reset() + if err := s.DecryptionKey.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"proposers\"") + return errors.Wrap(err, "decode field \"decryption_key\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode MultisigOrderChangingParameters") + return errors.Wrap(err, "decode Metadata") } // 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. @@ -29562,8 +28714,8 @@ func (s *MultisigOrderChangingParameters) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfMultisigOrderChangingParameters) { - name = jsonFieldsNameOfMultisigOrderChangingParameters[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfMetadata) { + name = jsonFieldsNameOfMetadata[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -29584,79 +28736,86 @@ func (s *MultisigOrderChangingParameters) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *MultisigOrderChangingParameters) MarshalJSON() ([]byte, error) { +func (s *Metadata) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *MultisigOrderChangingParameters) UnmarshalJSON(data []byte) error { +func (s *Metadata) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *Multisigs) Encode(e *jx.Encoder) { +func (s *Method) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *Multisigs) encodeFields(e *jx.Encoder) { +func (s *Method) encodeFields(e *jx.Encoder) { { - e.FieldStart("multisigs") - e.ArrStart() - for _, elem := range s.Multisigs { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("id") + e.Int64(s.ID) + } + { + e.FieldStart("method") + e.Str(s.Method) } } -var jsonFieldsNameOfMultisigs = [1]string{ - 0: "multisigs", +var jsonFieldsNameOfMethod = [2]string{ + 0: "id", + 1: "method", } -// Decode decodes Multisigs from json. -func (s *Multisigs) Decode(d *jx.Decoder) error { +// Decode decodes Method from json. +func (s *Method) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode Multisigs to 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 "multisigs": + case "id": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Multisigs = make([]Multisig, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem Multisig - if err := elem.Decode(d); err != nil { - return err - } - s.Multisigs = append(s.Multisigs, elem) - return nil - }); err != nil { + v, err := d.Int64() + s.ID = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"multisigs\"") + 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 Multisigs") + return errors.Wrap(err, "decode Method") } // 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. @@ -29668,8 +28827,8 @@ func (s *Multisigs) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfMultisigs) { - name = jsonFieldsNameOfMultisigs[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfMethod) { + name = jsonFieldsNameOfMethod[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -29690,270 +28849,131 @@ func (s *Multisigs) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *Multisigs) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *Multisigs) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes NftApprovedBy as json. -func (s NftApprovedBy) Encode(e *jx.Encoder) { - unwrapped := []NftApprovedByItem(s) - - e.ArrStart() - for _, elem := range unwrapped { - elem.Encode(e) - } - e.ArrEnd() -} - -// Decode decodes NftApprovedBy from json. -func (s *NftApprovedBy) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode NftApprovedBy to nil") - } - var unwrapped []NftApprovedByItem - if err := func() error { - unwrapped = make([]NftApprovedByItem, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem NftApprovedByItem - if err := elem.Decode(d); err != nil { - return err - } - unwrapped = append(unwrapped, elem) - return nil - }); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "alias") - } - *s = NftApprovedBy(unwrapped) - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s NftApprovedBy) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftApprovedBy) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode encodes NftApprovedByItem as json. -func (s NftApprovedByItem) Encode(e *jx.Encoder) { - e.Str(string(s)) -} - -// Decode decodes NftApprovedByItem from json. -func (s *NftApprovedByItem) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode NftApprovedByItem to nil") - } - v, err := d.StrBytes() - if err != nil { - return err - } - // Try to use constant string. - switch NftApprovedByItem(v) { - case NftApprovedByItemGetgems: - *s = NftApprovedByItemGetgems - case NftApprovedByItemTonkeeper: - *s = NftApprovedByItemTonkeeper - default: - *s = NftApprovedByItem(v) - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s NftApprovedByItem) MarshalJSON() ([]byte, error) { +func (s *Method) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftApprovedByItem) UnmarshalJSON(data []byte) error { +func (s *Method) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *NftCollection) Encode(e *jx.Encoder) { +func (s *MethodExecutionResult) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *NftCollection) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } - { - e.FieldStart("next_item_index") - e.Int64(s.NextItemIndex) - } +func (s *MethodExecutionResult) encodeFields(e *jx.Encoder) { { - if s.Owner.Set { - e.FieldStart("owner") - s.Owner.Encode(e) - } + e.FieldStart("success") + e.Bool(s.Success) } { - e.FieldStart("raw_collection_content") - e.Str(s.RawCollectionContent) + e.FieldStart("exit_code") + e.Int(s.ExitCode) } { - if s.Metadata.Set { - e.FieldStart("metadata") - s.Metadata.Encode(e) + e.FieldStart("stack") + e.ArrStart() + for _, elem := range s.Stack { + elem.Encode(e) } + e.ArrEnd() } { - if s.Previews != nil { - e.FieldStart("previews") - e.ArrStart() - for _, elem := range s.Previews { - elem.Encode(e) - } - e.ArrEnd() + if len(s.Decoded) != 0 { + e.FieldStart("decoded") + e.Raw(s.Decoded) } } - { - e.FieldStart("approved_by") - s.ApprovedBy.Encode(e) - } -} - -var jsonFieldsNameOfNftCollection = [7]string{ - 0: "address", - 1: "next_item_index", - 2: "owner", - 3: "raw_collection_content", - 4: "metadata", - 5: "previews", - 6: "approved_by", } -// Decode decodes NftCollection from json. -func (s *NftCollection) Decode(d *jx.Decoder) error { +var jsonFieldsNameOfMethodExecutionResult = [4]string{ + 0: "success", + 1: "exit_code", + 2: "stack", + 3: "decoded", +} + +// Decode decodes MethodExecutionResult from json. +func (s *MethodExecutionResult) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode NftCollection to nil") + return errors.New("invalid: unable to decode MethodExecutionResult to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "success": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Address = string(v) + v, err := d.Bool() + s.Success = bool(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") + return errors.Wrap(err, "decode field \"success\"") } - case "next_item_index": + case "exit_code": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Int64() - s.NextItemIndex = int64(v) - if err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"next_item_index\"") - } - 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 "raw_collection_content": - requiredBitSet[0] |= 1 << 3 - if err := func() error { - v, err := d.Str() - s.RawCollectionContent = string(v) + v, err := d.Int() + s.ExitCode = int(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"raw_collection_content\"") - } - case "metadata": - if err := func() error { - s.Metadata.Reset() - if err := s.Metadata.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"metadata\"") + return errors.Wrap(err, "decode field \"exit_code\"") } - case "previews": + case "stack": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Previews = make([]ImagePreview, 0) + s.Stack = make([]TvmStackRecord, 0) if err := d.Arr(func(d *jx.Decoder) error { - var elem ImagePreview + var elem TvmStackRecord if err := elem.Decode(d); err != nil { return err } - s.Previews = append(s.Previews, elem) + s.Stack = append(s.Stack, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"previews\"") + return errors.Wrap(err, "decode field \"stack\"") } - case "approved_by": - requiredBitSet[0] |= 1 << 6 + case "decoded": if err := func() error { - if err := s.ApprovedBy.Decode(d); err != nil { + v, err := d.RawAppend(nil) + s.Decoded = jx.Raw(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"approved_by\"") + return errors.Wrap(err, "decode field \"decoded\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode NftCollection") + return errors.Wrap(err, "decode MethodExecutionResult") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b01001011, + 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -29965,8 +28985,8 @@ func (s *NftCollection) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfNftCollection) { - name = jsonFieldsNameOfNftCollection[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfMethodExecutionResult) { + name = jsonFieldsNameOfMethodExecutionResult[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -29987,460 +29007,240 @@ func (s *NftCollection) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *NftCollection) MarshalJSON() ([]byte, error) { +func (s *MethodExecutionResult) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftCollection) UnmarshalJSON(data []byte) error { +func (s *MethodExecutionResult) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s NftCollectionMetadata) Encode(e *jx.Encoder) { +func (s *MisbehaviourPunishmentConfig) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } -// encodeFields implements json.Marshaler. -func (s NftCollectionMetadata) encodeFields(e *jx.Encoder) { - for k, elem := range s { - e.FieldStart(k) - - if len(elem) != 0 { - e.Raw(elem) - } +// encodeFields encodes fields. +func (s *MisbehaviourPunishmentConfig) encodeFields(e *jx.Encoder) { + { + e.FieldStart("default_flat_fine") + e.Int64(s.DefaultFlatFine) } -} - -// Decode decodes NftCollectionMetadata from json. -func (s *NftCollectionMetadata) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode NftCollectionMetadata to nil") + { + e.FieldStart("default_proportional_fine") + e.Int64(s.DefaultProportionalFine) } - 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 NftCollectionMetadata") + { + e.FieldStart("severity_flat_mult") + e.Int(s.SeverityFlatMult) } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s NftCollectionMetadata) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftCollectionMetadata) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s *NftCollections) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *NftCollections) encodeFields(e *jx.Encoder) { { - e.FieldStart("nft_collections") - e.ArrStart() - for _, elem := range s.NftCollections { - elem.Encode(e) - } - e.ArrEnd() + e.FieldStart("severity_proportional_mult") + e.Int(s.SeverityProportionalMult) + } + { + e.FieldStart("unpunishable_interval") + e.Int(s.UnpunishableInterval) + } + { + e.FieldStart("long_interval") + e.Int(s.LongInterval) + } + { + e.FieldStart("long_flat_mult") + e.Int(s.LongFlatMult) + } + { + e.FieldStart("long_proportional_mult") + e.Int(s.LongProportionalMult) + } + { + e.FieldStart("medium_interval") + e.Int(s.MediumInterval) + } + { + e.FieldStart("medium_flat_mult") + e.Int(s.MediumFlatMult) + } + { + e.FieldStart("medium_proportional_mult") + e.Int(s.MediumProportionalMult) } } -var jsonFieldsNameOfNftCollections = [1]string{ - 0: "nft_collections", +var jsonFieldsNameOfMisbehaviourPunishmentConfig = [11]string{ + 0: "default_flat_fine", + 1: "default_proportional_fine", + 2: "severity_flat_mult", + 3: "severity_proportional_mult", + 4: "unpunishable_interval", + 5: "long_interval", + 6: "long_flat_mult", + 7: "long_proportional_mult", + 8: "medium_interval", + 9: "medium_flat_mult", + 10: "medium_proportional_mult", } -// Decode decodes NftCollections from json. -func (s *NftCollections) Decode(d *jx.Decoder) error { +// Decode decodes MisbehaviourPunishmentConfig from json. +func (s *MisbehaviourPunishmentConfig) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode NftCollections to nil") + return errors.New("invalid: unable to decode MisbehaviourPunishmentConfig 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 "nft_collections": + case "default_flat_fine": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.NftCollections = make([]NftCollection, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem NftCollection - if err := elem.Decode(d); err != nil { - return err - } - s.NftCollections = append(s.NftCollections, elem) - return nil - }); err != nil { + v, err := d.Int64() + s.DefaultFlatFine = int64(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"nft_collections\"") + return errors.Wrap(err, "decode field \"default_flat_fine\"") } - default: - return d.Skip() - } - return nil - }); err != nil { - return errors.Wrap(err, "decode NftCollections") - } - // 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(jsonFieldsNameOfNftCollections) { - name = jsonFieldsNameOfNftCollections[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 *NftCollections) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftCollections) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s *NftItem) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *NftItem) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) - } - { - e.FieldStart("index") - e.Int64(s.Index) - } - { - if s.Owner.Set { - e.FieldStart("owner") - s.Owner.Encode(e) - } - } - { - if s.Collection.Set { - e.FieldStart("collection") - s.Collection.Encode(e) - } - } - { - e.FieldStart("verified") - e.Bool(s.Verified) - } - { - e.FieldStart("metadata") - s.Metadata.Encode(e) - } - { - if s.Sale.Set { - e.FieldStart("sale") - s.Sale.Encode(e) - } - } - { - if s.Previews != nil { - e.FieldStart("previews") - e.ArrStart() - for _, elem := range s.Previews { - elem.Encode(e) - } - e.ArrEnd() - } - } - { - if s.DNS.Set { - e.FieldStart("dns") - s.DNS.Encode(e) - } - } - { - e.FieldStart("approved_by") - s.ApprovedBy.Encode(e) - } - { - if s.IncludeCnft.Set { - e.FieldStart("include_cnft") - s.IncludeCnft.Encode(e) - } - } - { - e.FieldStart("trust") - s.Trust.Encode(e) - } - { - if s.CodeHash.Set { - e.FieldStart("code_hash") - s.CodeHash.Encode(e) - } - } - { - if s.DataHash.Set { - e.FieldStart("data_hash") - s.DataHash.Encode(e) - } - } -} - -var jsonFieldsNameOfNftItem = [14]string{ - 0: "address", - 1: "index", - 2: "owner", - 3: "collection", - 4: "verified", - 5: "metadata", - 6: "sale", - 7: "previews", - 8: "dns", - 9: "approved_by", - 10: "include_cnft", - 11: "trust", - 12: "code_hash", - 13: "data_hash", -} - -// Decode decodes NftItem from json. -func (s *NftItem) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode NftItem to nil") - } - var requiredBitSet [2]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 "index": + case "default_proportional_fine": requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Int64() - s.Index = int64(v) + s.DefaultProportionalFine = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"index\"") + return errors.Wrap(err, "decode field \"default_proportional_fine\"") } - case "owner": + case "severity_flat_mult": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Owner.Reset() - if err := s.Owner.Decode(d); err != nil { + v, err := d.Int() + s.SeverityFlatMult = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"owner\"") + return errors.Wrap(err, "decode field \"severity_flat_mult\"") } - case "collection": + case "severity_proportional_mult": + requiredBitSet[0] |= 1 << 3 if err := func() error { - s.Collection.Reset() - if err := s.Collection.Decode(d); err != nil { + v, err := d.Int() + s.SeverityProportionalMult = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"collection\"") + return errors.Wrap(err, "decode field \"severity_proportional_mult\"") } - case "verified": + case "unpunishable_interval": requiredBitSet[0] |= 1 << 4 if err := func() error { - v, err := d.Bool() - s.Verified = bool(v) + v, err := d.Int() + s.UnpunishableInterval = int(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"verified\"") + return errors.Wrap(err, "decode field \"unpunishable_interval\"") } - case "metadata": + case "long_interval": requiredBitSet[0] |= 1 << 5 if err := func() error { - if err := s.Metadata.Decode(d); err != nil { + v, err := d.Int() + s.LongInterval = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"metadata\"") + return errors.Wrap(err, "decode field \"long_interval\"") } - case "sale": + case "long_flat_mult": + requiredBitSet[0] |= 1 << 6 if err := func() error { - s.Sale.Reset() - if err := s.Sale.Decode(d); err != nil { + v, err := d.Int() + s.LongFlatMult = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"sale\"") + return errors.Wrap(err, "decode field \"long_flat_mult\"") } - case "previews": + case "long_proportional_mult": + requiredBitSet[0] |= 1 << 7 if err := func() error { - s.Previews = make([]ImagePreview, 0) - if err := d.Arr(func(d *jx.Decoder) error { - var elem ImagePreview - if err := elem.Decode(d); err != nil { - return err - } - s.Previews = append(s.Previews, elem) - return nil - }); err != nil { + v, err := d.Int() + s.LongProportionalMult = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"previews\"") + return errors.Wrap(err, "decode field \"long_proportional_mult\"") } - case "dns": + case "medium_interval": + requiredBitSet[1] |= 1 << 0 if err := func() error { - s.DNS.Reset() - if err := s.DNS.Decode(d); err != nil { + v, err := d.Int() + s.MediumInterval = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"dns\"") + return errors.Wrap(err, "decode field \"medium_interval\"") } - case "approved_by": + case "medium_flat_mult": requiredBitSet[1] |= 1 << 1 if err := func() error { - if err := s.ApprovedBy.Decode(d); err != nil { + v, err := d.Int() + s.MediumFlatMult = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"approved_by\"") + return errors.Wrap(err, "decode field \"medium_flat_mult\"") } - case "include_cnft": + case "medium_proportional_mult": + requiredBitSet[1] |= 1 << 2 if err := func() error { - s.IncludeCnft.Reset() - if err := s.IncludeCnft.Decode(d); err != nil { + v, err := d.Int() + s.MediumProportionalMult = int(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"include_cnft\"") - } - case "trust": - requiredBitSet[1] |= 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\"") - } - case "code_hash": - if err := func() error { - s.CodeHash.Reset() - if err := s.CodeHash.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"code_hash\"") - } - case "data_hash": - if err := func() error { - s.DataHash.Reset() - if err := s.DataHash.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"data_hash\"") + return errors.Wrap(err, "decode field \"medium_proportional_mult\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode NftItem") + return errors.Wrap(err, "decode MisbehaviourPunishmentConfig") } // Validate required fields. var failures []validate.FieldError for i, mask := range [2]uint8{ - 0b00110011, - 0b00001010, + 0b11111111, + 0b00000111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -30452,8 +29252,8 @@ func (s *NftItem) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfNftItem) { - name = jsonFieldsNameOfNftItem[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfMisbehaviourPunishmentConfig) { + name = jsonFieldsNameOfMisbehaviourPunishmentConfig[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -30474,103 +29274,154 @@ func (s *NftItem) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *NftItem) MarshalJSON() ([]byte, error) { +func (s *MisbehaviourPunishmentConfig) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftItem) UnmarshalJSON(data []byte) error { +func (s *MisbehaviourPunishmentConfig) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *NftItemCollection) Encode(e *jx.Encoder) { +func (s *MsgForwardPrices) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *NftItemCollection) encodeFields(e *jx.Encoder) { +func (s *MsgForwardPrices) encodeFields(e *jx.Encoder) { { - e.FieldStart("address") - e.Str(s.Address) + e.FieldStart("lump_price") + e.Int64(s.LumpPrice) } { - e.FieldStart("name") - e.Str(s.Name) + e.FieldStart("bit_price") + e.Int64(s.BitPrice) } { - e.FieldStart("description") - e.Str(s.Description) + e.FieldStart("cell_price") + e.Int64(s.CellPrice) + } + { + e.FieldStart("ihr_price_factor") + e.Int64(s.IhrPriceFactor) + } + { + e.FieldStart("first_frac") + e.Int64(s.FirstFrac) + } + { + e.FieldStart("next_frac") + e.Int64(s.NextFrac) } } -var jsonFieldsNameOfNftItemCollection = [3]string{ - 0: "address", - 1: "name", - 2: "description", +var jsonFieldsNameOfMsgForwardPrices = [6]string{ + 0: "lump_price", + 1: "bit_price", + 2: "cell_price", + 3: "ihr_price_factor", + 4: "first_frac", + 5: "next_frac", } -// Decode decodes NftItemCollection from json. -func (s *NftItemCollection) Decode(d *jx.Decoder) error { +// Decode decodes MsgForwardPrices from json. +func (s *MsgForwardPrices) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode NftItemCollection to nil") + return errors.New("invalid: unable to decode MsgForwardPrices to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "address": + case "lump_price": requiredBitSet[0] |= 1 << 0 if err := func() error { - v, err := d.Str() - s.Address = string(v) + v, err := d.Int64() + s.LumpPrice = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"address\"") + return errors.Wrap(err, "decode field \"lump_price\"") } - case "name": + case "bit_price": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Str() - s.Name = string(v) + v, err := d.Int64() + s.BitPrice = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"name\"") + return errors.Wrap(err, "decode field \"bit_price\"") } - case "description": + case "cell_price": requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Str() - s.Description = string(v) + v, err := d.Int64() + s.CellPrice = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"description\"") + return errors.Wrap(err, "decode field \"cell_price\"") + } + case "ihr_price_factor": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Int64() + s.IhrPriceFactor = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"ihr_price_factor\"") + } + case "first_frac": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Int64() + s.FirstFrac = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"first_frac\"") + } + case "next_frac": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Int64() + s.NextFrac = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"next_frac\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode NftItemCollection") + return errors.Wrap(err, "decode MsgForwardPrices") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000111, + 0b00111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -30582,8 +29433,8 @@ func (s *NftItemCollection) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfNftItemCollection) { - name = jsonFieldsNameOfNftItemCollection[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfMsgForwardPrices) { + name = jsonFieldsNameOfMsgForwardPrices[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -30604,229 +29455,188 @@ func (s *NftItemCollection) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *NftItemCollection) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftItemCollection) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s NftItemMetadata) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields implements json.Marshaler. -func (s NftItemMetadata) encodeFields(e *jx.Encoder) { - for k, elem := range s { - e.FieldStart(k) - - if len(elem) != 0 { - e.Raw(elem) - } - } -} - -// Decode decodes NftItemMetadata from json. -func (s *NftItemMetadata) Decode(d *jx.Decoder) error { - if s == nil { - return errors.New("invalid: unable to decode NftItemMetadata 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 NftItemMetadata") - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s NftItemMetadata) MarshalJSON() ([]byte, error) { +func (s *MsgForwardPrices) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftItemMetadata) UnmarshalJSON(data []byte) error { +func (s *MsgForwardPrices) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *NftItemTransferAction) Encode(e *jx.Encoder) { +func (s *Multisig) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *NftItemTransferAction) encodeFields(e *jx.Encoder) { +func (s *Multisig) encodeFields(e *jx.Encoder) { { - if s.Sender.Set { - e.FieldStart("sender") - s.Sender.Encode(e) - } + e.FieldStart("address") + e.Str(s.Address) } { - if s.Recipient.Set { - e.FieldStart("recipient") - s.Recipient.Encode(e) - } + e.FieldStart("seqno") + e.Str(s.Seqno) } { - e.FieldStart("nft") - e.Str(s.Nft) + e.FieldStart("threshold") + e.Int32(s.Threshold) } { - if s.Comment.Set { - e.FieldStart("comment") - s.Comment.Encode(e) + e.FieldStart("signers") + e.ArrStart() + for _, elem := range s.Signers { + e.Str(elem) } + e.ArrEnd() } { - if s.EncryptedComment.Set { - e.FieldStart("encrypted_comment") - s.EncryptedComment.Encode(e) - } - } - { - if s.Payload.Set { - e.FieldStart("payload") - s.Payload.Encode(e) + e.FieldStart("proposers") + e.ArrStart() + for _, elem := range s.Proposers { + e.Str(elem) } + e.ArrEnd() } { - if s.Refund.Set { - e.FieldStart("refund") - s.Refund.Encode(e) + e.FieldStart("orders") + e.ArrStart() + for _, elem := range s.Orders { + elem.Encode(e) } + e.ArrEnd() } } -var jsonFieldsNameOfNftItemTransferAction = [7]string{ - 0: "sender", - 1: "recipient", - 2: "nft", - 3: "comment", - 4: "encrypted_comment", - 5: "payload", - 6: "refund", +var jsonFieldsNameOfMultisig = [6]string{ + 0: "address", + 1: "seqno", + 2: "threshold", + 3: "signers", + 4: "proposers", + 5: "orders", } -// Decode decodes NftItemTransferAction from json. -func (s *NftItemTransferAction) Decode(d *jx.Decoder) error { +// Decode decodes Multisig from json. +func (s *Multisig) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode NftItemTransferAction to nil") + return errors.New("invalid: unable to decode Multisig to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "sender": - if err := func() error { - s.Sender.Reset() - if err := s.Sender.Decode(d); err != nil { - return err - } - return nil - }(); err != nil { - return errors.Wrap(err, "decode field \"sender\"") - } - case "recipient": + case "address": + requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Recipient.Reset() - if err := s.Recipient.Decode(d); err != nil { + v, err := d.Str() + s.Address = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"recipient\"") + return errors.Wrap(err, "decode field \"address\"") } - case "nft": - requiredBitSet[0] |= 1 << 2 + case "seqno": + requiredBitSet[0] |= 1 << 1 if err := func() error { v, err := d.Str() - s.Nft = string(v) + s.Seqno = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"nft\"") + return errors.Wrap(err, "decode field \"seqno\"") } - case "comment": + case "threshold": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.Comment.Reset() - if err := s.Comment.Decode(d); err != nil { + v, err := d.Int32() + s.Threshold = int32(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"comment\"") + return errors.Wrap(err, "decode field \"threshold\"") } - case "encrypted_comment": + case "signers": + requiredBitSet[0] |= 1 << 3 if err := func() error { - s.EncryptedComment.Reset() - if err := s.EncryptedComment.Decode(d); err != nil { + 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 \"encrypted_comment\"") + return errors.Wrap(err, "decode field \"signers\"") } - case "payload": + case "proposers": + requiredBitSet[0] |= 1 << 4 if err := func() error { - s.Payload.Reset() - if err := s.Payload.Decode(d); err != nil { + 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 \"payload\"") + return errors.Wrap(err, "decode field \"proposers\"") } - case "refund": + case "orders": + requiredBitSet[0] |= 1 << 5 if err := func() error { - s.Refund.Reset() - if err := s.Refund.Decode(d); err != nil { + s.Orders = make([]MultisigOrder, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem MultisigOrder + if err := elem.Decode(d); err != nil { + return err + } + s.Orders = append(s.Orders, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"refund\"") + return errors.Wrap(err, "decode field \"orders\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode NftItemTransferAction") + return errors.Wrap(err, "decode Multisig") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00000100, + 0b00111111, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -30838,8 +29648,8 @@ func (s *NftItemTransferAction) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfNftItemTransferAction) { - name = jsonFieldsNameOfNftItemTransferAction[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfMultisig) { + name = jsonFieldsNameOfMultisig[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -30860,275 +29670,279 @@ func (s *NftItemTransferAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *NftItemTransferAction) MarshalJSON() ([]byte, error) { +func (s *Multisig) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftItemTransferAction) UnmarshalJSON(data []byte) error { +func (s *Multisig) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *NftItems) Encode(e *jx.Encoder) { +func (s *MultisigOrder) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *NftItems) encodeFields(e *jx.Encoder) { +func (s *MultisigOrder) encodeFields(e *jx.Encoder) { { - e.FieldStart("nft_items") + e.FieldStart("address") + e.Str(s.Address) + } + { + e.FieldStart("order_seqno") + e.Str(s.OrderSeqno) + } + { + e.FieldStart("threshold") + e.Int32(s.Threshold) + } + { + e.FieldStart("sent_for_execution") + e.Bool(s.SentForExecution) + } + { + e.FieldStart("signers") e.ArrStart() - for _, elem := range s.NftItems { - elem.Encode(e) + for _, elem := range s.Signers { + e.Str(elem) + } + e.ArrEnd() + } + { + e.FieldStart("approvals_num") + e.Int32(s.ApprovalsNum) + } + { + e.FieldStart("expiration_date") + e.Int64(s.ExpirationDate) + } + { + 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 jsonFieldsNameOfNftItems = [1]string{ - 0: "nft_items", +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 NftItems from json. -func (s *NftItems) Decode(d *jx.Decoder) error { +// Decode decodes MultisigOrder from json. +func (s *MultisigOrder) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode NftItems to 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) { - case "nft_items": + case "address": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.NftItems = 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.NftItems = append(s.NftItems, elem) - return nil - }); err != nil { + v, err := d.Str() + s.Address = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"nft_items\"") + return errors.Wrap(err, "decode field \"address\"") } - default: - return d.Skip() - } - return nil - }); err != nil { - return errors.Wrap(err, "decode NftItems") - } - // 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(jsonFieldsNameOfNftItems) { - name = jsonFieldsNameOfNftItems[fieldIdx] - } else { - name = strconv.Itoa(fieldIdx) + case "order_seqno": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Str() + s.OrderSeqno = string(v) + if err != nil { + return err } - failures = append(failures, validate.FieldError{ - Name: name, - Error: validate.ErrFieldRequired, - }) - // Reset bit. - result &^= 1 << bitIdx + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"order_seqno\"") } - } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} - } - - return nil -} - -// MarshalJSON implements stdjson.Marshaler. -func (s *NftItems) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} - s.Encode(&e) - return e.Bytes(), nil -} - -// UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftItems) UnmarshalJSON(data []byte) error { - d := jx.DecodeBytes(data) - return s.Decode(d) -} - -// Encode implements json.Marshaler. -func (s *NftOperation) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() -} - -// encodeFields encodes fields. -func (s *NftOperation) encodeFields(e *jx.Encoder) { - { - e.FieldStart("operation") - e.Str(s.Operation) - } - { - 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("item") - s.Item.Encode(e) - } -} - -var jsonFieldsNameOfNftOperation = [7]string{ - 0: "operation", - 1: "utime", - 2: "lt", - 3: "transaction_hash", - 4: "source", - 5: "destination", - 6: "item", -} - -// Decode decodes NftOperation from json. -func (s *NftOperation) Decode(d *jx.Decoder) error { - if s == 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 "operation": - requiredBitSet[0] |= 1 << 0 + case "threshold": + requiredBitSet[0] |= 1 << 2 if err := func() error { - v, err := d.Str() - s.Operation = string(v) + v, err := d.Int32() + s.Threshold = int32(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"operation\"") + return errors.Wrap(err, "decode field \"threshold\"") } - case "utime": - requiredBitSet[0] |= 1 << 1 + case "sent_for_execution": + requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Int64() - s.Utime = int64(v) + v, err := d.Bool() + s.SentForExecution = bool(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"utime\"") + return errors.Wrap(err, "decode field \"sent_for_execution\"") } - case "lt": - requiredBitSet[0] |= 1 << 2 + case "signers": + requiredBitSet[0] |= 1 << 4 + 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 "approvals_num": + requiredBitSet[0] |= 1 << 5 + if err := func() error { + v, err := d.Int32() + s.ApprovalsNum = int32(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"approvals_num\"") + } + case "expiration_date": + requiredBitSet[0] |= 1 << 6 if err := func() error { v, err := d.Int64() - s.Lt = int64(v) + s.ExpirationDate = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"lt\"") + return errors.Wrap(err, "decode field \"expiration_date\"") } - case "transaction_hash": - requiredBitSet[0] |= 1 << 3 + case "risk": + requiredBitSet[0] |= 1 << 7 if err := func() error { - v, err := d.Str() - s.TransactionHash = string(v) + if err := s.Risk.Decode(d); err != nil { + return err + } + return nil + }(); 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 \"transaction_hash\"") + return errors.Wrap(err, "decode field \"creation_date\"") } - case "source": + case "signed_by": + requiredBitSet[1] |= 1 << 1 if err := func() error { - s.Source.Reset() - if err := s.Source.Decode(d); err != nil { + 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 \"source\"") + return errors.Wrap(err, "decode field \"signed_by\"") } - case "destination": + case "multisig_address": + requiredBitSet[1] |= 1 << 2 if err := func() error { - s.Destination.Reset() - if err := s.Destination.Decode(d); err != nil { + v, err := d.Str() + s.MultisigAddress = string(v) + if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"destination\"") + return errors.Wrap(err, "decode field \"multisig_address\"") } - case "item": - requiredBitSet[0] |= 1 << 6 + case "changing_parameters": if err := func() error { - if err := s.Item.Decode(d); err != nil { + s.ChangingParameters.Reset() + if err := s.ChangingParameters.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"item\"") + return errors.Wrap(err, "decode field \"changing_parameters\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode NftOperation") + return errors.Wrap(err, "decode MultisigOrder") } // Validate required fields. var failures []validate.FieldError - for i, mask := range [1]uint8{ - 0b01001111, + 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. @@ -31140,8 +29954,8 @@ func (s *NftOperation) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfNftOperation) { - name = jsonFieldsNameOfNftOperation[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfMultisigOrder) { + name = jsonFieldsNameOfMultisigOrder[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -31162,96 +29976,127 @@ func (s *NftOperation) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *NftOperation) MarshalJSON() ([]byte, error) { +func (s *MultisigOrder) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftOperation) UnmarshalJSON(data []byte) error { +func (s *MultisigOrder) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *NftOperations) Encode(e *jx.Encoder) { +func (s *MultisigOrderChangingParameters) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *NftOperations) encodeFields(e *jx.Encoder) { +func (s *MultisigOrderChangingParameters) encodeFields(e *jx.Encoder) { { - e.FieldStart("operations") + e.FieldStart("threshold") + e.Int32(s.Threshold) + } + { + e.FieldStart("signers") e.ArrStart() - for _, elem := range s.Operations { - elem.Encode(e) + for _, elem := range s.Signers { + e.Str(elem) } e.ArrEnd() } { - if s.NextFrom.Set { - e.FieldStart("next_from") - s.NextFrom.Encode(e) - } + e.FieldStart("proposers") + e.ArrStart() + for _, elem := range s.Proposers { + e.Str(elem) + } + e.ArrEnd() } } -var jsonFieldsNameOfNftOperations = [2]string{ - 0: "operations", - 1: "next_from", +var jsonFieldsNameOfMultisigOrderChangingParameters = [3]string{ + 0: "threshold", + 1: "signers", + 2: "proposers", } -// Decode decodes NftOperations from json. -func (s *NftOperations) Decode(d *jx.Decoder) error { +// Decode decodes MultisigOrderChangingParameters from json. +func (s *MultisigOrderChangingParameters) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode NftOperations to 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 "operations": + case "threshold": requiredBitSet[0] |= 1 << 0 if err := func() error { - s.Operations = make([]NftOperation, 0) + 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 NftOperation - if err := elem.Decode(d); err != nil { + var elem string + v, err := d.Str() + elem = string(v) + if err != nil { return err } - s.Operations = append(s.Operations, elem) + s.Signers = append(s.Signers, elem) return nil }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"operations\"") + return errors.Wrap(err, "decode field \"signers\"") } - case "next_from": + case "proposers": + requiredBitSet[0] |= 1 << 2 if err := func() error { - s.NextFrom.Reset() - if err := s.NextFrom.Decode(d); err != nil { + 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 \"next_from\"") + return errors.Wrap(err, "decode field \"proposers\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode NftOperations") + return errors.Wrap(err, "decode MultisigOrderChangingParameters") } // 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. @@ -31263,8 +30108,8 @@ func (s *NftOperations) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfNftOperations) { - name = jsonFieldsNameOfNftOperations[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfMultisigOrderChangingParameters) { + name = jsonFieldsNameOfMultisigOrderChangingParameters[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -31285,127 +30130,79 @@ func (s *NftOperations) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *NftOperations) MarshalJSON() ([]byte, error) { +func (s *MultisigOrderChangingParameters) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftOperations) UnmarshalJSON(data []byte) error { +func (s *MultisigOrderChangingParameters) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } // Encode implements json.Marshaler. -func (s *NftPurchaseAction) Encode(e *jx.Encoder) { +func (s *Multisigs) Encode(e *jx.Encoder) { e.ObjStart() s.encodeFields(e) e.ObjEnd() } // encodeFields encodes fields. -func (s *NftPurchaseAction) encodeFields(e *jx.Encoder) { - { - e.FieldStart("auction_type") - s.AuctionType.Encode(e) - } - { - e.FieldStart("amount") - s.Amount.Encode(e) - } - { - e.FieldStart("nft") - s.Nft.Encode(e) - } - { - e.FieldStart("seller") - s.Seller.Encode(e) - } +func (s *Multisigs) encodeFields(e *jx.Encoder) { { - e.FieldStart("buyer") - s.Buyer.Encode(e) + e.FieldStart("multisigs") + e.ArrStart() + for _, elem := range s.Multisigs { + elem.Encode(e) + } + e.ArrEnd() } } -var jsonFieldsNameOfNftPurchaseAction = [5]string{ - 0: "auction_type", - 1: "amount", - 2: "nft", - 3: "seller", - 4: "buyer", +var jsonFieldsNameOfMultisigs = [1]string{ + 0: "multisigs", } -// Decode decodes NftPurchaseAction from json. -func (s *NftPurchaseAction) Decode(d *jx.Decoder) error { +// Decode decodes Multisigs from json. +func (s *Multisigs) 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 Multisigs to nil") } var requiredBitSet [1]uint8 if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { switch string(k) { - case "auction_type": + case "multisigs": 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 { + s.Multisigs = make([]Multisig, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem Multisig + if err := elem.Decode(d); err != nil { + return err + } + s.Multisigs = append(s.Multisigs, elem) + return nil + }); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"buyer\"") + return errors.Wrap(err, "decode field \"multisigs\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode NftPurchaseAction") + return errors.Wrap(err, "decode Multisigs") } // 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. @@ -31417,8 +30214,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(jsonFieldsNameOfMultisigs) { + name = jsonFieldsNameOfMultisigs[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -31439,105 +30236,171 @@ func (s *NftPurchaseAction) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *NftPurchaseAction) MarshalJSON() ([]byte, error) { +func (s *Multisigs) 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 *Multisigs) 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 encodes NftApprovedBy as json. +func (s NftApprovedBy) Encode(e *jx.Encoder) { + unwrapped := []NftApprovedByItem(s) + + e.ArrStart() + for _, elem := range unwrapped { + elem.Encode(e) + } + e.ArrEnd() } -// Decode decodes NftPurchaseActionAuctionType from json. -func (s *NftPurchaseActionAuctionType) Decode(d *jx.Decoder) error { +// Decode decodes NftApprovedBy from json. +func (s *NftApprovedBy) 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 + return errors.New("invalid: unable to decode NftApprovedBy to nil") } - // 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) + var unwrapped []NftApprovedByItem + if err := func() error { + unwrapped = make([]NftApprovedByItem, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NftApprovedByItem + if err := elem.Decode(d); err != nil { + return err + } + unwrapped = append(unwrapped, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "alias") } - + *s = NftApprovedBy(unwrapped) return nil } // MarshalJSON implements stdjson.Marshaler. -func (s NftPurchaseActionAuctionType) MarshalJSON() ([]byte, error) { +func (s NftApprovedBy) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NftPurchaseActionAuctionType) UnmarshalJSON(data []byte) error { +func (s *NftApprovedBy) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode implements json.Marshaler. -func (s *NominatorRewardEntry) Encode(e *jx.Encoder) { - e.ObjStart() - s.encodeFields(e) - e.ObjEnd() +// Encode encodes NftApprovedByItem as json. +func (s NftApprovedByItem) Encode(e *jx.Encoder) { + e.Str(string(s)) } -// encodeFields encodes fields. -func (s *NominatorRewardEntry) encodeFields(e *jx.Encoder) { - { - e.FieldStart("address") - e.Str(s.Address) +// Decode decodes NftApprovedByItem from json. +func (s *NftApprovedByItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NftApprovedByItem to nil") } + v, err := d.StrBytes() + if err != nil { + return err + } + // Try to use constant string. + switch NftApprovedByItem(v) { + case NftApprovedByItemGetgems: + *s = NftApprovedByItemGetgems + case NftApprovedByItemTonkeeper: + *s = NftApprovedByItemTonkeeper + default: + *s = NftApprovedByItem(v) + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s NftApprovedByItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NftApprovedByItem) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *NftCollection) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *NftCollection) encodeFields(e *jx.Encoder) { { - e.FieldStart("weight") - e.Float64(s.Weight) + e.FieldStart("address") + e.Str(s.Address) } { - e.FieldStart("reward") - e.Int64(s.Reward) + e.FieldStart("next_item_index") + e.Int64(s.NextItemIndex) } { - e.FieldStart("effective_stake") - e.Int64(s.EffectiveStake) + if s.Owner.Set { + e.FieldStart("owner") + s.Owner.Encode(e) + } } { - e.FieldStart("stake") - e.Int64(s.Stake) + e.FieldStart("raw_collection_content") + e.Str(s.RawCollectionContent) + } + { + if s.Metadata.Set { + e.FieldStart("metadata") + s.Metadata.Encode(e) + } + } + { + if s.Previews != nil { + e.FieldStart("previews") + e.ArrStart() + for _, elem := range s.Previews { + elem.Encode(e) + } + e.ArrEnd() + } + } + { + e.FieldStart("approved_by") + s.ApprovedBy.Encode(e) } } -var jsonFieldsNameOfNominatorRewardEntry = [5]string{ +var jsonFieldsNameOfNftCollection = [7]string{ 0: "address", - 1: "weight", - 2: "reward", - 3: "effective_stake", - 4: "stake", + 1: "next_item_index", + 2: "owner", + 3: "raw_collection_content", + 4: "metadata", + 5: "previews", + 6: "approved_by", } -// Decode decodes NominatorRewardEntry from json. -func (s *NominatorRewardEntry) Decode(d *jx.Decoder) error { +// Decode decodes NftCollection from json. +func (s *NftCollection) Decode(d *jx.Decoder) error { if s == nil { - return errors.New("invalid: unable to decode NominatorRewardEntry to nil") + return errors.New("invalid: unable to decode NftCollection to nil") } var requiredBitSet [1]uint8 @@ -31555,65 +30418,88 @@ func (s *NominatorRewardEntry) Decode(d *jx.Decoder) error { }(); err != nil { return errors.Wrap(err, "decode field \"address\"") } - case "weight": + case "next_item_index": requiredBitSet[0] |= 1 << 1 if err := func() error { - v, err := d.Float64() - s.Weight = float64(v) + v, err := d.Int64() + s.NextItemIndex = int64(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"weight\"") + return errors.Wrap(err, "decode field \"next_item_index\"") } - case "reward": - requiredBitSet[0] |= 1 << 2 + case "owner": if err := func() error { - v, err := d.Int64() - s.Reward = int64(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 \"reward\"") + return errors.Wrap(err, "decode field \"owner\"") } - case "effective_stake": + case "raw_collection_content": requiredBitSet[0] |= 1 << 3 if err := func() error { - v, err := d.Int64() - s.EffectiveStake = int64(v) + v, err := d.Str() + s.RawCollectionContent = string(v) if err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"effective_stake\"") + return errors.Wrap(err, "decode field \"raw_collection_content\"") } - case "stake": - requiredBitSet[0] |= 1 << 4 + case "metadata": if err := func() error { - v, err := d.Int64() - s.Stake = int64(v) - if err != nil { + s.Metadata.Reset() + if err := s.Metadata.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"stake\"") + return errors.Wrap(err, "decode field \"metadata\"") + } + case "previews": + if err := func() error { + s.Previews = make([]ImagePreview, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ImagePreview + if err := elem.Decode(d); err != nil { + return err + } + s.Previews = append(s.Previews, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"previews\"") + } + case "approved_by": + requiredBitSet[0] |= 1 << 6 + if err := func() error { + if err := s.ApprovedBy.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"approved_by\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode NominatorRewardEntry") + return errors.Wrap(err, "decode NftCollection") } // Validate required fields. var failures []validate.FieldError for i, mask := range [1]uint8{ - 0b00011111, + 0b01001011, } { if result := (requiredBitSet[i] & mask) ^ mask; result != 0 { // Mask only required fields and check equality to mask using XOR. @@ -31625,8 +30511,8 @@ func (s *NominatorRewardEntry) Decode(d *jx.Decoder) error { bitIdx := bits.TrailingZeros8(result) fieldIdx := i*8 + bitIdx var name string - if fieldIdx < len(jsonFieldsNameOfNominatorRewardEntry) { - name = jsonFieldsNameOfNominatorRewardEntry[fieldIdx] + if fieldIdx < len(jsonFieldsNameOfNftCollection) { + name = jsonFieldsNameOfNftCollection[fieldIdx] } else { name = strconv.Itoa(fieldIdx) } @@ -31647,75 +30533,1735 @@ func (s *NominatorRewardEntry) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s *NominatorRewardEntry) MarshalJSON() ([]byte, error) { +func (s *NftCollection) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *NominatorRewardEntry) UnmarshalJSON(data []byte) error { +func (s *NftCollection) 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 +// Encode implements json.Marshaler. +func (s NftCollectionMetadata) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s NftCollectionMetadata) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } } - 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") +// Decode decodes NftCollectionMetadata from json. +func (s *NftCollectionMetadata) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NftCollectionMetadata to nil") } - o.Set = true - if err := o.Value.Decode(d); err != nil { - return err + 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 NftCollectionMetadata") } + return nil } // MarshalJSON implements stdjson.Marshaler. -func (s OptAccountAddress) MarshalJSON() ([]byte, error) { +func (s NftCollectionMetadata) 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 *NftCollectionMetadata) 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 *NftCollections) 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") - } - o.Set = true - o.Value = make(AccountCurrenciesBalance) - if err := o.Value.Decode(d); err != nil { - return err +// encodeFields encodes fields. +func (s *NftCollections) encodeFields(e *jx.Encoder) { + { + e.FieldStart("nft_collections") + e.ArrStart() + for _, elem := range s.NftCollections { + elem.Encode(e) + } + e.ArrEnd() } - return nil } -// MarshalJSON implements stdjson.Marshaler. -func (s OptAccountCurrenciesBalance) MarshalJSON() ([]byte, error) { - e := jx.Encoder{} +var jsonFieldsNameOfNftCollections = [1]string{ + 0: "nft_collections", +} + +// Decode decodes NftCollections from json. +func (s *NftCollections) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NftCollections to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "nft_collections": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.NftCollections = make([]NftCollection, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem NftCollection + if err := elem.Decode(d); err != nil { + return err + } + s.NftCollections = append(s.NftCollections, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"nft_collections\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode NftCollections") + } + // 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(jsonFieldsNameOfNftCollections) { + name = jsonFieldsNameOfNftCollections[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 *NftCollections) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NftCollections) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *NftItem) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *NftItem) encodeFields(e *jx.Encoder) { + { + e.FieldStart("address") + e.Str(s.Address) + } + { + e.FieldStart("index") + e.Int64(s.Index) + } + { + if s.Owner.Set { + e.FieldStart("owner") + s.Owner.Encode(e) + } + } + { + if s.Collection.Set { + e.FieldStart("collection") + s.Collection.Encode(e) + } + } + { + e.FieldStart("verified") + e.Bool(s.Verified) + } + { + e.FieldStart("metadata") + s.Metadata.Encode(e) + } + { + if s.Sale.Set { + e.FieldStart("sale") + s.Sale.Encode(e) + } + } + { + if s.Previews != nil { + e.FieldStart("previews") + e.ArrStart() + for _, elem := range s.Previews { + elem.Encode(e) + } + e.ArrEnd() + } + } + { + if s.DNS.Set { + e.FieldStart("dns") + s.DNS.Encode(e) + } + } + { + e.FieldStart("approved_by") + s.ApprovedBy.Encode(e) + } + { + if s.IncludeCnft.Set { + e.FieldStart("include_cnft") + s.IncludeCnft.Encode(e) + } + } + { + e.FieldStart("trust") + s.Trust.Encode(e) + } + { + if s.CodeHash.Set { + e.FieldStart("code_hash") + s.CodeHash.Encode(e) + } + } + { + if s.DataHash.Set { + e.FieldStart("data_hash") + s.DataHash.Encode(e) + } + } +} + +var jsonFieldsNameOfNftItem = [14]string{ + 0: "address", + 1: "index", + 2: "owner", + 3: "collection", + 4: "verified", + 5: "metadata", + 6: "sale", + 7: "previews", + 8: "dns", + 9: "approved_by", + 10: "include_cnft", + 11: "trust", + 12: "code_hash", + 13: "data_hash", +} + +// Decode decodes NftItem from json. +func (s *NftItem) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NftItem to nil") + } + var requiredBitSet [2]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 "index": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int64() + s.Index = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"index\"") + } + 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 "collection": + if err := func() error { + s.Collection.Reset() + if err := s.Collection.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"collection\"") + } + case "verified": + requiredBitSet[0] |= 1 << 4 + if err := func() error { + v, err := d.Bool() + s.Verified = bool(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"verified\"") + } + case "metadata": + requiredBitSet[0] |= 1 << 5 + 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 "sale": + if err := func() error { + s.Sale.Reset() + if err := s.Sale.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"sale\"") + } + case "previews": + if err := func() error { + s.Previews = make([]ImagePreview, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem ImagePreview + if err := elem.Decode(d); err != nil { + return err + } + s.Previews = append(s.Previews, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"previews\"") + } + case "dns": + if err := func() error { + s.DNS.Reset() + if err := s.DNS.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"dns\"") + } + case "approved_by": + requiredBitSet[1] |= 1 << 1 + if err := func() error { + if err := s.ApprovedBy.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"approved_by\"") + } + case "include_cnft": + if err := func() error { + s.IncludeCnft.Reset() + if err := s.IncludeCnft.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"include_cnft\"") + } + case "trust": + requiredBitSet[1] |= 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\"") + } + case "code_hash": + if err := func() error { + s.CodeHash.Reset() + if err := s.CodeHash.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"code_hash\"") + } + case "data_hash": + if err := func() error { + s.DataHash.Reset() + if err := s.DataHash.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"data_hash\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode NftItem") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b00110011, + 0b00001010, + } { + 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(jsonFieldsNameOfNftItem) { + name = jsonFieldsNameOfNftItem[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 *NftItem) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NftItem) 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() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *NftItemCollection) encodeFields(e *jx.Encoder) { + { + e.FieldStart("address") + e.Str(s.Address) + } + { + e.FieldStart("name") + e.Str(s.Name) + } + { + e.FieldStart("description") + e.Str(s.Description) + } +} + +var jsonFieldsNameOfNftItemCollection = [3]string{ + 0: "address", + 1: "name", + 2: "description", +} + +// Decode decodes NftItemCollection from json. +func (s *NftItemCollection) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NftItemCollection 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 "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 "description": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Description = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"description\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode NftItemCollection") + } + // 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(jsonFieldsNameOfNftItemCollection) { + name = jsonFieldsNameOfNftItemCollection[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 *NftItemCollection) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NftItemCollection) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s NftItemMetadata) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields implements json.Marshaler. +func (s NftItemMetadata) encodeFields(e *jx.Encoder) { + for k, elem := range s { + e.FieldStart(k) + + if len(elem) != 0 { + e.Raw(elem) + } + } +} + +// Decode decodes NftItemMetadata from json. +func (s *NftItemMetadata) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NftItemMetadata 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 NftItemMetadata") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s NftItemMetadata) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NftItemMetadata) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *NftItemTransferAction) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *NftItemTransferAction) encodeFields(e *jx.Encoder) { + { + if s.Sender.Set { + e.FieldStart("sender") + s.Sender.Encode(e) + } + } + { + if s.Recipient.Set { + e.FieldStart("recipient") + s.Recipient.Encode(e) + } + } + { + e.FieldStart("nft") + e.Str(s.Nft) + } + { + 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.Payload.Set { + e.FieldStart("payload") + s.Payload.Encode(e) + } + } + { + if s.Refund.Set { + e.FieldStart("refund") + s.Refund.Encode(e) + } + } +} + +var jsonFieldsNameOfNftItemTransferAction = [7]string{ + 0: "sender", + 1: "recipient", + 2: "nft", + 3: "comment", + 4: "encrypted_comment", + 5: "payload", + 6: "refund", +} + +// Decode decodes NftItemTransferAction from json. +func (s *NftItemTransferAction) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NftItemTransferAction to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "sender": + if err := func() error { + s.Sender.Reset() + if err := s.Sender.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"sender\"") + } + case "recipient": + if err := func() error { + s.Recipient.Reset() + if err := s.Recipient.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"recipient\"") + } + case "nft": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Str() + s.Nft = string(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"nft\"") + } + 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 "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\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode NftItemTransferAction") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b00000100, + } { + 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(jsonFieldsNameOfNftItemTransferAction) { + name = jsonFieldsNameOfNftItemTransferAction[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 *NftItemTransferAction) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NftItemTransferAction) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *NftItems) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *NftItems) encodeFields(e *jx.Encoder) { + { + e.FieldStart("nft_items") + e.ArrStart() + for _, elem := range s.NftItems { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfNftItems = [1]string{ + 0: "nft_items", +} + +// Decode decodes NftItems from json. +func (s *NftItems) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NftItems to nil") + } + var requiredBitSet [1]uint8 + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "nft_items": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.NftItems = 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.NftItems = append(s.NftItems, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"nft_items\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode NftItems") + } + // 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(jsonFieldsNameOfNftItems) { + name = jsonFieldsNameOfNftItems[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 *NftItems) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NftItems) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *NftOperation) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *NftOperation) encodeFields(e *jx.Encoder) { + { + e.FieldStart("operation") + e.Str(s.Operation) + } + { + 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("item") + s.Item.Encode(e) + } +} + +var jsonFieldsNameOfNftOperation = [7]string{ + 0: "operation", + 1: "utime", + 2: "lt", + 3: "transaction_hash", + 4: "source", + 5: "destination", + 6: "item", +} + +// Decode decodes NftOperation from json. +func (s *NftOperation) Decode(d *jx.Decoder) error { + if s == 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 "operation": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Str() + s.Operation = string(v) + if 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 "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 NftOperation") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [1]uint8{ + 0b01001111, + } { + 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(jsonFieldsNameOfNftOperation) { + name = jsonFieldsNameOfNftOperation[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 *NftOperation) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NftOperation) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *NftOperations) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// 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() + } + { + if s.NextFrom.Set { + e.FieldStart("next_from") + s.NextFrom.Encode(e) + } + } +} + +var jsonFieldsNameOfNftOperations = [2]string{ + 0: "operations", + 1: "next_from", +} + +// 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") + } + 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([]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") + } + // 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 *NftOperations) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NftOperations) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *NftPurchaseAction) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *NftPurchaseAction) encodeFields(e *jx.Encoder) { + { + e.FieldStart("auction_type") + s.AuctionType.Encode(e) + } + { + e.FieldStart("amount") + s.Amount.Encode(e) + } + { + 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 implements json.Marshaler. +func (s *NominatorRewardEntry) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *NominatorRewardEntry) encodeFields(e *jx.Encoder) { + { + e.FieldStart("address") + e.Str(s.Address) + } + { + e.FieldStart("weight") + e.Float64(s.Weight) + } + { + e.FieldStart("reward") + e.Int64(s.Reward) + } + { + e.FieldStart("effective_stake") + e.Int64(s.EffectiveStake) + } + { + e.FieldStart("stake") + e.Int64(s.Stake) + } +} + +var jsonFieldsNameOfNominatorRewardEntry = [5]string{ + 0: "address", + 1: "weight", + 2: "reward", + 3: "effective_stake", + 4: "stake", +} + +// Decode decodes NominatorRewardEntry from json. +func (s *NominatorRewardEntry) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode NominatorRewardEntry 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 "weight": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Float64() + s.Weight = float64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"weight\"") + } + case "reward": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int64() + s.Reward = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"reward\"") + } + case "effective_stake": + requiredBitSet[0] |= 1 << 3 + if err := func() error { + v, err := d.Int64() + s.EffectiveStake = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"effective_stake\"") + } + case "stake": + requiredBitSet[0] |= 1 << 4 + 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\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode NominatorRewardEntry") + } + // 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(jsonFieldsNameOfNominatorRewardEntry) { + name = jsonFieldsNameOfNominatorRewardEntry[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 *NominatorRewardEntry) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *NominatorRewardEntry) 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 } @@ -33712,6 +34258,39 @@ func (s *OptGetAccountsReq) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode encodes GetCocoonWorkersUnauthorizedError as json. +func (o OptGetCocoonWorkersUnauthorizedError) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes GetCocoonWorkersUnauthorizedError from json. +func (o *OptGetCocoonWorkersUnauthorizedError) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptGetCocoonWorkersUnauthorizedError to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptGetCocoonWorkersUnauthorizedError) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptGetCocoonWorkersUnauthorizedError) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes GetJettonInfosByAddressesReq as json. func (o OptGetJettonInfosByAddressesReq) Encode(e *jx.Encoder) { if !o.Set { @@ -34483,64 +35062,130 @@ func (o OptNilString) Encode(e *jx.Encoder) { if !o.Set { return } - if o.Null { - e.Null() - return - } - e.Str(string(o.Value)) + if o.Null { + e.Null() + return + } + e.Str(string(o.Value)) +} + +// Decode decodes string from json. +func (o *OptNilString) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptNilString to nil") + } + if d.Next() == jx.Null { + if err := d.Null(); err != nil { + return err + } + + var v string + o.Value = v + o.Set = true + o.Null = true + return nil + } + o.Set = true + o.Null = false + v, err := d.Str() + if err != nil { + return err + } + o.Value = string(v) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptNilString) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptNilString) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes PictureDNS as json. +func (o OptPictureDNS) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) +} + +// Decode decodes PictureDNS from json. +func (o *OptPictureDNS) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptPictureDNS to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptPictureDNS) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptPictureDNS) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes PostCocoonQueryUnauthorizedError as json. +func (o OptPostCocoonQueryUnauthorizedError) Encode(e *jx.Encoder) { + if !o.Set { + return + } + o.Value.Encode(e) } -// Decode decodes string from json. -func (o *OptNilString) Decode(d *jx.Decoder) error { +// Decode decodes PostCocoonQueryUnauthorizedError from json. +func (o *OptPostCocoonQueryUnauthorizedError) Decode(d *jx.Decoder) error { if o == nil { - return errors.New("invalid: unable to decode OptNilString to nil") - } - if d.Next() == jx.Null { - if err := d.Null(); err != nil { - return err - } - - var v string - o.Value = v - o.Set = true - o.Null = true - return nil + return errors.New("invalid: unable to decode OptPostCocoonQueryUnauthorizedError to nil") } o.Set = true - o.Null = false - v, err := d.Str() - if err != nil { + if err := o.Value.Decode(d); err != nil { return err } - o.Value = string(v) return nil } // MarshalJSON implements stdjson.Marshaler. -func (s OptNilString) MarshalJSON() ([]byte, error) { +func (s OptPostCocoonQueryUnauthorizedError) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptNilString) UnmarshalJSON(data []byte) error { +func (s *OptPostCocoonQueryUnauthorizedError) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } -// Encode encodes PictureDNS as json. -func (o OptPictureDNS) Encode(e *jx.Encoder) { +// Encode encodes PostCocoonV1ChatCompletionsUnauthorizedError as json. +func (o OptPostCocoonV1ChatCompletionsUnauthorizedError) Encode(e *jx.Encoder) { if !o.Set { return } o.Value.Encode(e) } -// Decode decodes PictureDNS from json. -func (o *OptPictureDNS) Decode(d *jx.Decoder) error { +// Decode decodes PostCocoonV1ChatCompletionsUnauthorizedError from json. +func (o *OptPostCocoonV1ChatCompletionsUnauthorizedError) Decode(d *jx.Decoder) error { if o == nil { - return errors.New("invalid: unable to decode OptPictureDNS to nil") + return errors.New("invalid: unable to decode OptPostCocoonV1ChatCompletionsUnauthorizedError to nil") } o.Set = true if err := o.Value.Decode(d); err != nil { @@ -34550,14 +35195,14 @@ func (o *OptPictureDNS) Decode(d *jx.Decoder) error { } // MarshalJSON implements stdjson.Marshaler. -func (s OptPictureDNS) MarshalJSON() ([]byte, error) { +func (s OptPostCocoonV1ChatCompletionsUnauthorizedError) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *OptPictureDNS) UnmarshalJSON(data []byte) error { +func (s *OptPostCocoonV1ChatCompletionsUnauthorizedError) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } @@ -36357,112 +37002,570 @@ func (s *PoolInfo) Decode(d *jx.Decoder) error { case "max_nominators": requiredBitSet[1] |= 1 << 2 if err := func() error { - v, err := d.Int() - s.MaxNominators = int(v) - if err != nil { + v, err := d.Int() + s.MaxNominators = int(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_nominators\"") + } + case "liquid_jetton_master": + if err := func() error { + s.LiquidJettonMaster.Reset() + if err := s.LiquidJettonMaster.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"liquid_jetton_master\"") + } + case "nominators_stake": + requiredBitSet[1] |= 1 << 4 + if err := func() error { + v, err := d.Int64() + s.NominatorsStake = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"nominators_stake\"") + } + case "validator_stake": + requiredBitSet[1] |= 1 << 5 + if err := func() error { + v, err := d.Int64() + s.ValidatorStake = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"validator_stake\"") + } + case "cycle_length": + if err := func() error { + s.CycleLength.Reset() + if err := s.CycleLength.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"cycle_length\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode PoolInfo") + } + // Validate required fields. + var failures []validate.FieldError + for i, mask := range [2]uint8{ + 0b11111111, + 0b00110111, + } { + 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(jsonFieldsNameOfPoolInfo) { + name = jsonFieldsNameOfPoolInfo[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 *PoolInfo) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PoolInfo) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *PostCocoonQueryNotImplemented) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *PostCocoonQueryNotImplemented) encodeFields(e *jx.Encoder) { +} + +var jsonFieldsNameOfPostCocoonQueryNotImplemented = [0]string{} + +// Decode decodes PostCocoonQueryNotImplemented from json. +func (s *PostCocoonQueryNotImplemented) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PostCocoonQueryNotImplemented to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + default: + return d.Skip() + } + }); err != nil { + return errors.Wrap(err, "decode PostCocoonQueryNotImplemented") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *PostCocoonQueryNotImplemented) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PostCocoonQueryNotImplemented) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes PostCocoonQueryOKApplicationJSON as json. +func (s PostCocoonQueryOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := jx.Raw(s) + + if len(unwrapped) != 0 { + e.Raw(unwrapped) + } +} + +// Decode decodes PostCocoonQueryOKApplicationJSON from json. +func (s *PostCocoonQueryOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PostCocoonQueryOKApplicationJSON to nil") + } + var unwrapped jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + unwrapped = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "alias") + } + *s = PostCocoonQueryOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s PostCocoonQueryOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PostCocoonQueryOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *PostCocoonQueryUnauthorized) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *PostCocoonQueryUnauthorized) encodeFields(e *jx.Encoder) { + { + if s.Error.Set { + e.FieldStart("error") + s.Error.Encode(e) + } + } +} + +var jsonFieldsNameOfPostCocoonQueryUnauthorized = [1]string{ + 0: "error", +} + +// Decode decodes PostCocoonQueryUnauthorized from json. +func (s *PostCocoonQueryUnauthorized) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PostCocoonQueryUnauthorized to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "error": + if err := func() error { + s.Error.Reset() + if err := s.Error.Decode(d); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"error\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode PostCocoonQueryUnauthorized") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *PostCocoonQueryUnauthorized) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PostCocoonQueryUnauthorized) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *PostCocoonQueryUnauthorizedError) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *PostCocoonQueryUnauthorizedError) encodeFields(e *jx.Encoder) { + { + if s.Message.Set { + e.FieldStart("message") + s.Message.Encode(e) + } + } + { + if s.Type.Set { + e.FieldStart("type") + s.Type.Encode(e) + } + } +} + +var jsonFieldsNameOfPostCocoonQueryUnauthorizedError = [2]string{ + 0: "message", + 1: "type", +} + +// Decode decodes PostCocoonQueryUnauthorizedError from json. +func (s *PostCocoonQueryUnauthorizedError) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PostCocoonQueryUnauthorizedError to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "message": + if err := func() error { + s.Message.Reset() + if err := s.Message.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"max_nominators\"") + return errors.Wrap(err, "decode field \"message\"") } - case "liquid_jetton_master": + case "type": if err := func() error { - s.LiquidJettonMaster.Reset() - if err := s.LiquidJettonMaster.Decode(d); err != nil { + s.Type.Reset() + if err := s.Type.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"liquid_jetton_master\"") + return errors.Wrap(err, "decode field \"type\"") } - case "nominators_stake": - requiredBitSet[1] |= 1 << 4 + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode PostCocoonQueryUnauthorizedError") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *PostCocoonQueryUnauthorizedError) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PostCocoonQueryUnauthorizedError) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *PostCocoonV1ChatCompletionsNotImplemented) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *PostCocoonV1ChatCompletionsNotImplemented) encodeFields(e *jx.Encoder) { +} + +var jsonFieldsNameOfPostCocoonV1ChatCompletionsNotImplemented = [0]string{} + +// Decode decodes PostCocoonV1ChatCompletionsNotImplemented from json. +func (s *PostCocoonV1ChatCompletionsNotImplemented) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PostCocoonV1ChatCompletionsNotImplemented to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + default: + return d.Skip() + } + }); err != nil { + return errors.Wrap(err, "decode PostCocoonV1ChatCompletionsNotImplemented") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *PostCocoonV1ChatCompletionsNotImplemented) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PostCocoonV1ChatCompletionsNotImplemented) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode encodes PostCocoonV1ChatCompletionsOKApplicationJSON as json. +func (s PostCocoonV1ChatCompletionsOKApplicationJSON) Encode(e *jx.Encoder) { + unwrapped := jx.Raw(s) + + if len(unwrapped) != 0 { + e.Raw(unwrapped) + } +} + +// Decode decodes PostCocoonV1ChatCompletionsOKApplicationJSON from json. +func (s *PostCocoonV1ChatCompletionsOKApplicationJSON) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PostCocoonV1ChatCompletionsOKApplicationJSON to nil") + } + var unwrapped jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + unwrapped = jx.Raw(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "alias") + } + *s = PostCocoonV1ChatCompletionsOKApplicationJSON(unwrapped) + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s PostCocoonV1ChatCompletionsOKApplicationJSON) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PostCocoonV1ChatCompletionsOKApplicationJSON) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *PostCocoonV1ChatCompletionsUnauthorized) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *PostCocoonV1ChatCompletionsUnauthorized) encodeFields(e *jx.Encoder) { + { + if s.Error.Set { + e.FieldStart("error") + s.Error.Encode(e) + } + } +} + +var jsonFieldsNameOfPostCocoonV1ChatCompletionsUnauthorized = [1]string{ + 0: "error", +} + +// Decode decodes PostCocoonV1ChatCompletionsUnauthorized from json. +func (s *PostCocoonV1ChatCompletionsUnauthorized) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PostCocoonV1ChatCompletionsUnauthorized to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "error": if err := func() error { - v, err := d.Int64() - s.NominatorsStake = int64(v) - if err != nil { + s.Error.Reset() + if err := s.Error.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"nominators_stake\"") + return errors.Wrap(err, "decode field \"error\"") } - case "validator_stake": - requiredBitSet[1] |= 1 << 5 + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode PostCocoonV1ChatCompletionsUnauthorized") + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *PostCocoonV1ChatCompletionsUnauthorized) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *PostCocoonV1ChatCompletionsUnauthorized) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *PostCocoonV1ChatCompletionsUnauthorizedError) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *PostCocoonV1ChatCompletionsUnauthorizedError) encodeFields(e *jx.Encoder) { + { + if s.Message.Set { + e.FieldStart("message") + s.Message.Encode(e) + } + } + { + if s.Type.Set { + e.FieldStart("type") + s.Type.Encode(e) + } + } +} + +var jsonFieldsNameOfPostCocoonV1ChatCompletionsUnauthorizedError = [2]string{ + 0: "message", + 1: "type", +} + +// Decode decodes PostCocoonV1ChatCompletionsUnauthorizedError from json. +func (s *PostCocoonV1ChatCompletionsUnauthorizedError) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode PostCocoonV1ChatCompletionsUnauthorizedError to nil") + } + + if err := d.ObjBytes(func(d *jx.Decoder, k []byte) error { + switch string(k) { + case "message": if err := func() error { - v, err := d.Int64() - s.ValidatorStake = int64(v) - if err != nil { + s.Message.Reset() + if err := s.Message.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"validator_stake\"") + return errors.Wrap(err, "decode field \"message\"") } - case "cycle_length": + case "type": if err := func() error { - s.CycleLength.Reset() - if err := s.CycleLength.Decode(d); err != nil { + s.Type.Reset() + if err := s.Type.Decode(d); err != nil { return err } return nil }(); err != nil { - return errors.Wrap(err, "decode field \"cycle_length\"") + return errors.Wrap(err, "decode field \"type\"") } default: return d.Skip() } return nil }); err != nil { - return errors.Wrap(err, "decode PoolInfo") - } - // Validate required fields. - var failures []validate.FieldError - for i, mask := range [2]uint8{ - 0b11111111, - 0b00110111, - } { - 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(jsonFieldsNameOfPoolInfo) { - name = jsonFieldsNameOfPoolInfo[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 PostCocoonV1ChatCompletionsUnauthorizedError") } return nil } // MarshalJSON implements stdjson.Marshaler. -func (s *PoolInfo) MarshalJSON() ([]byte, error) { +func (s *PostCocoonV1ChatCompletionsUnauthorizedError) MarshalJSON() ([]byte, error) { e := jx.Encoder{} s.Encode(&e) return e.Bytes(), nil } // UnmarshalJSON implements stdjson.Unmarshaler. -func (s *PoolInfo) UnmarshalJSON(data []byte) error { +func (s *PostCocoonV1ChatCompletionsUnauthorizedError) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } diff --git a/pkg/oas/oas_operations_gen.go b/pkg/oas/oas_operations_gen.go index f80b2e8b..9a32118a 100644 --- a/pkg/oas/oas_operations_gen.go +++ b/pkg/oas/oas_operations_gen.go @@ -57,6 +57,7 @@ const ( GetBlockchainTransactionByMessageHashOperation OperationName = "GetBlockchainTransactionByMessageHash" GetBlockchainValidatorsOperation OperationName = "GetBlockchainValidators" GetChartRatesOperation OperationName = "GetChartRates" + GetCocoonWorkersOperation OperationName = "GetCocoonWorkers" GetDnsInfoOperation OperationName = "GetDnsInfo" GetDomainBidsOperation OperationName = "GetDomainBids" GetEventOperation OperationName = "GetEvent" @@ -112,6 +113,8 @@ const ( GetWalletInfoOperation OperationName = "GetWalletInfo" GetWalletsByPublicKeyOperation OperationName = "GetWalletsByPublicKey" GetWalletsByPublicKeyBulkOperation OperationName = "GetWalletsByPublicKeyBulk" + PostCocoonQueryOperation OperationName = "PostCocoonQuery" + PostCocoonV1ChatCompletionsOperation OperationName = "PostCocoonV1ChatCompletions" ReindexAccountOperation OperationName = "ReindexAccount" SearchAccountsOperation OperationName = "SearchAccounts" SendBlockchainMessageOperation OperationName = "SendBlockchainMessage" diff --git a/pkg/oas/oas_parameters_gen.go b/pkg/oas/oas_parameters_gen.go index eb18e33a..e5bb38a6 100644 --- a/pkg/oas/oas_parameters_gen.go +++ b/pkg/oas/oas_parameters_gen.go @@ -12644,6 +12644,128 @@ func decodeGetWalletsByPublicKeyParams(args [1]string, argsEscaped bool, r *http return params, nil } +// PostCocoonQueryParams is parameters of postCocoonQuery operation. +type PostCocoonQueryParams struct { + // Cocoon worker model name passed to the proxy. + Model OptString `json:",omitempty,omitzero"` + // HTTP path on the Cocoon worker (e.g. /v1/chat/completions). + Path OptString `json:",omitempty,omitzero"` +} + +func unpackPostCocoonQueryParams(packed middleware.Parameters) (params PostCocoonQueryParams) { + { + key := middleware.ParameterKey{ + Name: "model", + In: "query", + } + if v, ok := packed[key]; ok { + params.Model = v.(OptString) + } + } + { + key := middleware.ParameterKey{ + Name: "path", + In: "query", + } + if v, ok := packed[key]; ok { + params.Path = v.(OptString) + } + } + return params +} + +func decodePostCocoonQueryParams(args [0]string, argsEscaped bool, r *http.Request) (params PostCocoonQueryParams, _ error) { + q := uri.NewQueryDecoder(r.URL.Query()) + // Decode query: model. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "model", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotModelVal string + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToString(val) + if err != nil { + return err + } + + paramsDotModelVal = c + return nil + }(); err != nil { + return err + } + params.Model.SetTo(paramsDotModelVal) + return nil + }); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "model", + In: "query", + Err: err, + } + } + // Set default value for query: path. + { + val := string("/query") + params.Path.SetTo(val) + } + // Decode query: path. + if err := func() error { + cfg := uri.QueryParameterDecodingConfig{ + Name: "path", + Style: uri.QueryStyleForm, + Explode: true, + } + + if err := q.HasParam(cfg); err == nil { + if err := q.DecodeParam(cfg, func(d uri.Decoder) error { + var paramsDotPathVal string + if err := func() error { + val, err := d.DecodeValue() + if err != nil { + return err + } + + c, err := conv.ToString(val) + if err != nil { + return err + } + + paramsDotPathVal = c + return nil + }(); err != nil { + return err + } + params.Path.SetTo(paramsDotPathVal) + return nil + }); err != nil { + return err + } + } + return nil + }(); err != nil { + return params, &ogenerrors.DecodeParamError{ + Name: "path", + In: "query", + Err: err, + } + } + return params, nil +} + // ReindexAccountParams is parameters of reindexAccount operation. type ReindexAccountParams struct { // Account ID. diff --git a/pkg/oas/oas_request_decoders_gen.go b/pkg/oas/oas_request_decoders_gen.go index 2578d856..2e11aac5 100644 --- a/pkg/oas/oas_request_decoders_gen.go +++ b/pkg/oas/oas_request_decoders_gen.go @@ -1130,6 +1130,152 @@ func (s *Server) decodeGetWalletsByPublicKeyBulkRequest(r *http.Request) ( } } +func (s *Server) decodePostCocoonQueryRequest(r *http.Request) ( + req jx.Raw, + rawBody []byte, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = errors.Join(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = errors.Join(rerr, close()) + } + }() + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, rawBody, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, rawBody, close, validate.ErrBodyRequired + } + buf, err := io.ReadAll(r.Body) + defer func() { + _ = r.Body.Close() + }() + if err != nil { + return req, rawBody, close, err + } + + // Reset the body to allow for downstream reading. + r.Body = io.NopCloser(bytes.NewBuffer(buf)) + + if len(buf) == 0 { + return req, rawBody, close, validate.ErrBodyRequired + } + + rawBody = append(rawBody, buf...) + d := jx.DecodeBytes(buf) + + var request jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + request = jx.Raw(v) + if 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 req, rawBody, close, err + } + return request, rawBody, close, nil + default: + return req, rawBody, close, validate.InvalidContentType(ct) + } +} + +func (s *Server) decodePostCocoonV1ChatCompletionsRequest(r *http.Request) ( + req jx.Raw, + rawBody []byte, + close func() error, + rerr error, +) { + var closers []func() error + close = func() error { + var merr error + // Close in reverse order, to match defer behavior. + for i := len(closers) - 1; i >= 0; i-- { + c := closers[i] + merr = errors.Join(merr, c()) + } + return merr + } + defer func() { + if rerr != nil { + rerr = errors.Join(rerr, close()) + } + }() + ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type")) + if err != nil { + return req, rawBody, close, errors.Wrap(err, "parse media type") + } + switch { + case ct == "application/json": + if r.ContentLength == 0 { + return req, rawBody, close, validate.ErrBodyRequired + } + buf, err := io.ReadAll(r.Body) + defer func() { + _ = r.Body.Close() + }() + if err != nil { + return req, rawBody, close, err + } + + // Reset the body to allow for downstream reading. + r.Body = io.NopCloser(bytes.NewBuffer(buf)) + + if len(buf) == 0 { + return req, rawBody, close, validate.ErrBodyRequired + } + + rawBody = append(rawBody, buf...) + d := jx.DecodeBytes(buf) + + var request jx.Raw + if err := func() error { + v, err := d.RawAppend(nil) + request = jx.Raw(v) + if 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 req, rawBody, close, err + } + return request, rawBody, close, nil + default: + return req, rawBody, close, validate.InvalidContentType(ct) + } +} + func (s *Server) decodeSendBlockchainMessageRequest(r *http.Request) ( req *SendBlockchainMessageReq, rawBody []byte, diff --git a/pkg/oas/oas_request_encoders_gen.go b/pkg/oas/oas_request_encoders_gen.go index ab550d15..1b76e735 100644 --- a/pkg/oas/oas_request_encoders_gen.go +++ b/pkg/oas/oas_request_encoders_gen.go @@ -242,6 +242,38 @@ func encodeGetWalletsByPublicKeyBulkRequest( return nil } +func encodePostCocoonQueryRequest( + req jx.Raw, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + if len(req) != 0 { + e.Raw(req) + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + +func encodePostCocoonV1ChatCompletionsRequest( + req jx.Raw, + r *http.Request, +) error { + const contentType = "application/json" + e := new(jx.Encoder) + { + if len(req) != 0 { + e.Raw(req) + } + } + encoded := e.Bytes() + ht.SetBody(r, bytes.NewReader(encoded), contentType) + return nil +} + func encodeSendBlockchainMessageRequest( req *SendBlockchainMessageReq, r *http.Request, diff --git a/pkg/oas/oas_response_decoders_gen.go b/pkg/oas/oas_response_decoders_gen.go index dd54265d..34cc992f 100644 --- a/pkg/oas/oas_response_decoders_gen.go +++ b/pkg/oas/oas_response_decoders_gen.go @@ -4660,6 +4660,168 @@ func decodeGetChartRatesResponse(resp *http.Response) (res *GetChartRatesOK, _ e return res, errors.Wrap(defRes, "error") } +func decodeGetCocoonWorkersResponse(resp *http.Response) (res GetCocoonWorkersRes, _ 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 CocoonWorkersResponse + 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) + } + case 401: + // Code 401. + 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 GetCocoonWorkersUnauthorized + 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) + } + case 501: + // Code 501. + 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 GetCocoonWorkersNotImplemented + 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 decodeGetDnsInfoResponse(resp *http.Response) (res *DomainInfo, _ error) { switch resp.StatusCode { case 200: @@ -9553,6 +9715,312 @@ func decodeGetWalletsByPublicKeyBulkResponse(resp *http.Response) (res *WalletsB return res, errors.Wrap(defRes, "error") } +func decodePostCocoonQueryResponse(resp *http.Response) (res PostCocoonQueryRes, _ 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 PostCocoonQueryOKApplicationJSON + 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) + } + case 401: + // Code 401. + 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 PostCocoonQueryUnauthorized + 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) + } + case 501: + // Code 501. + 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 PostCocoonQueryNotImplemented + 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 decodePostCocoonV1ChatCompletionsResponse(resp *http.Response) (res PostCocoonV1ChatCompletionsRes, _ 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 PostCocoonV1ChatCompletionsOKApplicationJSON + 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) + } + case 401: + // Code 401. + 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 PostCocoonV1ChatCompletionsUnauthorized + 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) + } + case 501: + // Code 501. + 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 PostCocoonV1ChatCompletionsNotImplemented + 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 decodeReindexAccountResponse(resp *http.Response) (res *ReindexAccountOK, _ error) { switch resp.StatusCode { case 200: diff --git a/pkg/oas/oas_response_encoders_gen.go b/pkg/oas/oas_response_encoders_gen.go index 6708a821..7a95a669 100644 --- a/pkg/oas/oas_response_encoders_gen.go +++ b/pkg/oas/oas_response_encoders_gen.go @@ -751,6 +751,52 @@ func encodeGetChartRatesResponse(response *GetChartRatesOK, w http.ResponseWrite return nil } +func encodeGetCocoonWorkersResponse(response GetCocoonWorkersRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *CocoonWorkersResponse: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetCocoonWorkersUnauthorized: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(401) + span.SetStatus(codes.Error, http.StatusText(401)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *GetCocoonWorkersNotImplemented: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(501) + span.SetStatus(codes.Error, http.StatusText(501)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeGetDnsInfoResponse(response *DomainInfo, w http.ResponseWriter, span trace.Span) error { w.Header().Set("Content-Type", "application/json; charset=utf-8") w.WriteHeader(200) @@ -1525,6 +1571,98 @@ func encodeGetWalletsByPublicKeyBulkResponse(response *WalletsByPublicKeys, w ht return nil } +func encodePostCocoonQueryResponse(response PostCocoonQueryRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *PostCocoonQueryOKApplicationJSON: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *PostCocoonQueryUnauthorized: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(401) + span.SetStatus(codes.Error, http.StatusText(401)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *PostCocoonQueryNotImplemented: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(501) + span.SetStatus(codes.Error, http.StatusText(501)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + +func encodePostCocoonV1ChatCompletionsResponse(response PostCocoonV1ChatCompletionsRes, w http.ResponseWriter, span trace.Span) error { + switch response := response.(type) { + case *PostCocoonV1ChatCompletionsOKApplicationJSON: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(200) + span.SetStatus(codes.Ok, http.StatusText(200)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *PostCocoonV1ChatCompletionsUnauthorized: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(401) + span.SetStatus(codes.Error, http.StatusText(401)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + case *PostCocoonV1ChatCompletionsNotImplemented: + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(501) + span.SetStatus(codes.Error, http.StatusText(501)) + + e := new(jx.Encoder) + response.Encode(e) + if _, err := e.WriteTo(w); err != nil { + return errors.Wrap(err, "write") + } + + return nil + + default: + return errors.Errorf("unexpected response type: %T", response) + } +} + func encodeReindexAccountResponse(response *ReindexAccountOK, w http.ResponseWriter, span trace.Span) error { w.WriteHeader(200) span.SetStatus(codes.Ok, http.StatusText(200)) diff --git a/pkg/oas/oas_router_gen.go b/pkg/oas/oas_router_gen.go index 0ed39090..d51d9704 100644 --- a/pkg/oas/oas_router_gen.go +++ b/pkg/oas/oas_router_gen.go @@ -35,16 +35,22 @@ var ( rn27AllowedHeaders = map[string]string{ "POST": "Content-Type", } + rn196AllowedHeaders = map[string]string{ + "POST": "Content-Type", + } rn192AllowedHeaders = map[string]string{ "POST": "Content-Type", } + rn193AllowedHeaders = map[string]string{ + "POST": "Content-Type", + } rn22AllowedHeaders = map[string]string{ "POST": "Accept-Language,Content-Type", } - rn91AllowedHeaders = map[string]string{ + rn92AllowedHeaders = map[string]string{ "GET": "Accept-Language", } - rn110AllowedHeaders = map[string]string{ + rn111AllowedHeaders = map[string]string{ "GET": "Accept-Language", } rn31AllowedHeaders = map[string]string{ @@ -53,31 +59,31 @@ var ( rn32AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn105AllowedHeaders = map[string]string{ + rn106AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn193AllowedHeaders = map[string]string{ + rn197AllowedHeaders = map[string]string{ "POST": "Content-Type", } rn12AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn125AllowedHeaders = map[string]string{ + rn126AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn120AllowedHeaders = map[string]string{ + rn121AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn124AllowedHeaders = map[string]string{ + rn125AllowedHeaders = map[string]string{ "GET": "Accept-Language", } - rn189AllowedHeaders = map[string]string{ + rn190AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn171AllowedHeaders = map[string]string{ + rn172AllowedHeaders = map[string]string{ "GET": "Accept-Language", } - rn174AllowedHeaders = map[string]string{ + rn175AllowedHeaders = map[string]string{ "GET": "Accept-Language", } rn45AllowedHeaders = map[string]string{ @@ -86,7 +92,7 @@ var ( rn23AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn196AllowedHeaders = map[string]string{ + rn200AllowedHeaders = map[string]string{ "POST": "Content-Type", } rn24AllowedHeaders = map[string]string{ @@ -1496,7 +1502,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "POST", - allowedHeaders: rn192AllowedHeaders, + allowedHeaders: rn196AllowedHeaders, acceptPost: "application/json", acceptPatch: "", }) @@ -1647,6 +1653,95 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } + case 'c': // Prefix: "cocoon/" + + if l := len("cocoon/"); len(elem) >= l && elem[0:l] == "cocoon/" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'q': // Prefix: "query" + + if l := len("query"); len(elem) >= l && elem[0:l] == "query" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handlePostCocoonQueryRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn192AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } + + return + } + + case 'v': // Prefix: "v1/chat/completions" + + if l := len("v1/chat/completions"); len(elem) >= l && elem[0:l] == "v1/chat/completions" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handlePostCocoonV1ChatCompletionsRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn193AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } + + return + } + + case 'w': // Prefix: "workers" + + if l := len("workers"); len(elem) >= l && elem[0:l] == "workers" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetCocoonWorkersRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } + case 'd': // Prefix: "dns/" if l := len("dns/"); len(elem) >= l && elem[0:l] == "dns/" { @@ -1852,7 +1947,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", - allowedHeaders: rn91AllowedHeaders, + allowedHeaders: rn92AllowedHeaders, acceptPost: "", acceptPatch: "", }) @@ -1879,7 +1974,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", - allowedHeaders: rn110AllowedHeaders, + allowedHeaders: rn111AllowedHeaders, acceptPost: "", acceptPatch: "", }) @@ -2080,7 +2175,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "POST", - allowedHeaders: rn105AllowedHeaders, + allowedHeaders: rn106AllowedHeaders, acceptPost: "application/json", acceptPatch: "", }) @@ -2877,7 +2972,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "POST", - allowedHeaders: rn193AllowedHeaders, + allowedHeaders: rn197AllowedHeaders, acceptPost: "application/json", acceptPatch: "", }) @@ -3033,7 +3128,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "POST", - allowedHeaders: rn125AllowedHeaders, + allowedHeaders: rn126AllowedHeaders, acceptPost: "application/json", acceptPatch: "", }) @@ -3095,7 +3190,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "POST", - allowedHeaders: rn120AllowedHeaders, + allowedHeaders: rn121AllowedHeaders, acceptPost: "application/json", acceptPatch: "", }) @@ -3211,7 +3306,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", - allowedHeaders: rn124AllowedHeaders, + allowedHeaders: rn125AllowedHeaders, acceptPost: "", acceptPatch: "", }) @@ -3326,7 +3421,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "POST", - allowedHeaders: rn189AllowedHeaders, + allowedHeaders: rn190AllowedHeaders, acceptPost: "application/json", acceptPatch: "", }) @@ -3762,7 +3857,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", - allowedHeaders: rn171AllowedHeaders, + allowedHeaders: rn172AllowedHeaders, acceptPost: "", acceptPatch: "", }) @@ -3816,7 +3911,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", - allowedHeaders: rn174AllowedHeaders, + allowedHeaders: rn175AllowedHeaders, acceptPost: "", acceptPatch: "", }) @@ -4056,7 +4151,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "POST", - allowedHeaders: rn196AllowedHeaders, + allowedHeaders: rn200AllowedHeaders, acceptPost: "application/json", acceptPatch: "", }) @@ -5680,6 +5775,95 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } + case 'c': // Prefix: "cocoon/" + + if l := len("cocoon/"); len(elem) >= l && elem[0:l] == "cocoon/" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'q': // Prefix: "query" + + if l := len("query"); len(elem) >= l && elem[0:l] == "query" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = PostCocoonQueryOperation + r.summary = "" + r.operationID = "postCocoonQuery" + r.operationGroup = "" + r.pathPattern = "/v2/cocoon/query" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + case 'v': // Prefix: "v1/chat/completions" + + if l := len("v1/chat/completions"); len(elem) >= l && elem[0:l] == "v1/chat/completions" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = PostCocoonV1ChatCompletionsOperation + r.summary = "" + r.operationID = "postCocoonV1ChatCompletions" + r.operationGroup = "" + r.pathPattern = "/v2/cocoon/v1/chat/completions" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + case 'w': // Prefix: "workers" + + if l := len("workers"); len(elem) >= l && elem[0:l] == "workers" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetCocoonWorkersOperation + r.summary = "" + r.operationID = "getCocoonWorkers" + r.operationGroup = "" + r.pathPattern = "/v2/cocoon/workers" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + } + case 'd': // Prefix: "dns/" if l := len("dns/"); len(elem) >= l && elem[0:l] == "dns/" { diff --git a/pkg/oas/oas_schemas_gen.go b/pkg/oas/oas_schemas_gen.go index 7b1f6cc6..1734564f 100644 --- a/pkg/oas/oas_schemas_gen.go +++ b/pkg/oas/oas_schemas_gen.go @@ -4411,6 +4411,86 @@ func (s *BouncePhaseType) UnmarshalText(data []byte) error { type ChartPoints [][]float64 +// Ref: #/components/schemas/CocoonWorkerInstance +type CocoonWorkerInstance struct { + Coefficient int64 `json:"coefficient"` + ActiveRequests int64 `json:"active_requests"` + MaxActiveRequests int64 `json:"max_active_requests"` +} + +// GetCoefficient returns the value of Coefficient. +func (s *CocoonWorkerInstance) GetCoefficient() int64 { + return s.Coefficient +} + +// GetActiveRequests returns the value of ActiveRequests. +func (s *CocoonWorkerInstance) GetActiveRequests() int64 { + return s.ActiveRequests +} + +// GetMaxActiveRequests returns the value of MaxActiveRequests. +func (s *CocoonWorkerInstance) GetMaxActiveRequests() int64 { + return s.MaxActiveRequests +} + +// SetCoefficient sets the value of Coefficient. +func (s *CocoonWorkerInstance) SetCoefficient(val int64) { + s.Coefficient = val +} + +// SetActiveRequests sets the value of ActiveRequests. +func (s *CocoonWorkerInstance) SetActiveRequests(val int64) { + s.ActiveRequests = val +} + +// SetMaxActiveRequests sets the value of MaxActiveRequests. +func (s *CocoonWorkerInstance) SetMaxActiveRequests(val int64) { + s.MaxActiveRequests = val +} + +// Ref: #/components/schemas/CocoonWorkerType +type CocoonWorkerType struct { + Name string `json:"name"` + Workers []CocoonWorkerInstance `json:"workers"` +} + +// GetName returns the value of Name. +func (s *CocoonWorkerType) GetName() string { + return s.Name +} + +// GetWorkers returns the value of Workers. +func (s *CocoonWorkerType) GetWorkers() []CocoonWorkerInstance { + return s.Workers +} + +// SetName sets the value of Name. +func (s *CocoonWorkerType) SetName(val string) { + s.Name = val +} + +// SetWorkers sets the value of Workers. +func (s *CocoonWorkerType) SetWorkers(val []CocoonWorkerInstance) { + s.Workers = val +} + +// Ref: #/components/schemas/CocoonWorkersResponse +type CocoonWorkersResponse struct { + Types []CocoonWorkerType `json:"types"` +} + +// GetTypes returns the value of Types. +func (s *CocoonWorkersResponse) GetTypes() []CocoonWorkerType { + return s.Types +} + +// SetTypes sets the value of Types. +func (s *CocoonWorkersResponse) SetTypes(val []CocoonWorkerType) { + s.Types = val +} + +func (*CocoonWorkersResponse) getCocoonWorkersRes() {} + // Ref: #/components/schemas/ComputePhase type ComputePhase struct { Skipped bool `json:"skipped"` @@ -6784,6 +6864,51 @@ func (s *GetChartRatesOK) SetPoints(val ChartPoints) { s.Points = val } +type GetCocoonWorkersNotImplemented struct{} + +func (*GetCocoonWorkersNotImplemented) getCocoonWorkersRes() {} + +type GetCocoonWorkersUnauthorized struct { + Error OptGetCocoonWorkersUnauthorizedError `json:"error"` +} + +// GetError returns the value of Error. +func (s *GetCocoonWorkersUnauthorized) GetError() OptGetCocoonWorkersUnauthorizedError { + return s.Error +} + +// SetError sets the value of Error. +func (s *GetCocoonWorkersUnauthorized) SetError(val OptGetCocoonWorkersUnauthorizedError) { + s.Error = val +} + +func (*GetCocoonWorkersUnauthorized) getCocoonWorkersRes() {} + +type GetCocoonWorkersUnauthorizedError struct { + Message OptString `json:"message"` + Type OptString `json:"type"` +} + +// GetMessage returns the value of Message. +func (s *GetCocoonWorkersUnauthorizedError) GetMessage() OptString { + return s.Message +} + +// GetType returns the value of Type. +func (s *GetCocoonWorkersUnauthorizedError) GetType() OptString { + return s.Type +} + +// SetMessage sets the value of Message. +func (s *GetCocoonWorkersUnauthorizedError) SetMessage(val OptString) { + s.Message = val +} + +// SetType sets the value of Type. +func (s *GetCocoonWorkersUnauthorizedError) SetType(val OptString) { + s.Type = val +} + type GetJettonInfosByAddressesReq struct { AccountIds []string `json:"account_ids"` } @@ -13927,6 +14052,52 @@ func (o OptGetBlockchainAccountTransactionsSortOrder) Or(d GetBlockchainAccountT return d } +// NewOptGetCocoonWorkersUnauthorizedError returns new OptGetCocoonWorkersUnauthorizedError with value set to v. +func NewOptGetCocoonWorkersUnauthorizedError(v GetCocoonWorkersUnauthorizedError) OptGetCocoonWorkersUnauthorizedError { + return OptGetCocoonWorkersUnauthorizedError{ + Value: v, + Set: true, + } +} + +// OptGetCocoonWorkersUnauthorizedError is optional GetCocoonWorkersUnauthorizedError. +type OptGetCocoonWorkersUnauthorizedError struct { + Value GetCocoonWorkersUnauthorizedError + Set bool +} + +// IsSet returns true if OptGetCocoonWorkersUnauthorizedError was set. +func (o OptGetCocoonWorkersUnauthorizedError) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptGetCocoonWorkersUnauthorizedError) Reset() { + var v GetCocoonWorkersUnauthorizedError + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptGetCocoonWorkersUnauthorizedError) SetTo(v GetCocoonWorkersUnauthorizedError) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptGetCocoonWorkersUnauthorizedError) Get() (v GetCocoonWorkersUnauthorizedError, 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 OptGetCocoonWorkersUnauthorizedError) Or(d GetCocoonWorkersUnauthorizedError) GetCocoonWorkersUnauthorizedError { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptGetJettonInfosByAddressesReq returns new OptGetJettonInfosByAddressesReq with value set to v. func NewOptGetJettonInfosByAddressesReq(v GetJettonInfosByAddressesReq) OptGetJettonInfosByAddressesReq { return OptGetJettonInfosByAddressesReq{ @@ -15094,6 +15265,98 @@ func (o OptPictureDNS) Or(d PictureDNS) PictureDNS { return d } +// NewOptPostCocoonQueryUnauthorizedError returns new OptPostCocoonQueryUnauthorizedError with value set to v. +func NewOptPostCocoonQueryUnauthorizedError(v PostCocoonQueryUnauthorizedError) OptPostCocoonQueryUnauthorizedError { + return OptPostCocoonQueryUnauthorizedError{ + Value: v, + Set: true, + } +} + +// OptPostCocoonQueryUnauthorizedError is optional PostCocoonQueryUnauthorizedError. +type OptPostCocoonQueryUnauthorizedError struct { + Value PostCocoonQueryUnauthorizedError + Set bool +} + +// IsSet returns true if OptPostCocoonQueryUnauthorizedError was set. +func (o OptPostCocoonQueryUnauthorizedError) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptPostCocoonQueryUnauthorizedError) Reset() { + var v PostCocoonQueryUnauthorizedError + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptPostCocoonQueryUnauthorizedError) SetTo(v PostCocoonQueryUnauthorizedError) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptPostCocoonQueryUnauthorizedError) Get() (v PostCocoonQueryUnauthorizedError, 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 OptPostCocoonQueryUnauthorizedError) Or(d PostCocoonQueryUnauthorizedError) PostCocoonQueryUnauthorizedError { + if v, ok := o.Get(); ok { + return v + } + return d +} + +// NewOptPostCocoonV1ChatCompletionsUnauthorizedError returns new OptPostCocoonV1ChatCompletionsUnauthorizedError with value set to v. +func NewOptPostCocoonV1ChatCompletionsUnauthorizedError(v PostCocoonV1ChatCompletionsUnauthorizedError) OptPostCocoonV1ChatCompletionsUnauthorizedError { + return OptPostCocoonV1ChatCompletionsUnauthorizedError{ + Value: v, + Set: true, + } +} + +// OptPostCocoonV1ChatCompletionsUnauthorizedError is optional PostCocoonV1ChatCompletionsUnauthorizedError. +type OptPostCocoonV1ChatCompletionsUnauthorizedError struct { + Value PostCocoonV1ChatCompletionsUnauthorizedError + Set bool +} + +// IsSet returns true if OptPostCocoonV1ChatCompletionsUnauthorizedError was set. +func (o OptPostCocoonV1ChatCompletionsUnauthorizedError) IsSet() bool { return o.Set } + +// Reset unsets value. +func (o *OptPostCocoonV1ChatCompletionsUnauthorizedError) Reset() { + var v PostCocoonV1ChatCompletionsUnauthorizedError + o.Value = v + o.Set = false +} + +// SetTo sets value to v. +func (o *OptPostCocoonV1ChatCompletionsUnauthorizedError) SetTo(v PostCocoonV1ChatCompletionsUnauthorizedError) { + o.Set = true + o.Value = v +} + +// Get returns value and boolean that denotes whether value was set. +func (o OptPostCocoonV1ChatCompletionsUnauthorizedError) Get() (v PostCocoonV1ChatCompletionsUnauthorizedError, 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 OptPostCocoonV1ChatCompletionsUnauthorizedError) Or(d PostCocoonV1ChatCompletionsUnauthorizedError) PostCocoonV1ChatCompletionsUnauthorizedError { + if v, ok := o.Get(); ok { + return v + } + return d +} + // NewOptPrice returns new OptPrice with value set to v. func NewOptPrice(v Price) OptPrice { return OptPrice{ @@ -16811,6 +17074,104 @@ func (s *PoolInfo) SetCycleLength(val OptInt64) { s.CycleLength = val } +type PostCocoonQueryNotImplemented struct{} + +func (*PostCocoonQueryNotImplemented) postCocoonQueryRes() {} + +type PostCocoonQueryOKApplicationJSON jx.Raw + +func (*PostCocoonQueryOKApplicationJSON) postCocoonQueryRes() {} + +type PostCocoonQueryUnauthorized struct { + Error OptPostCocoonQueryUnauthorizedError `json:"error"` +} + +// GetError returns the value of Error. +func (s *PostCocoonQueryUnauthorized) GetError() OptPostCocoonQueryUnauthorizedError { + return s.Error +} + +// SetError sets the value of Error. +func (s *PostCocoonQueryUnauthorized) SetError(val OptPostCocoonQueryUnauthorizedError) { + s.Error = val +} + +func (*PostCocoonQueryUnauthorized) postCocoonQueryRes() {} + +type PostCocoonQueryUnauthorizedError struct { + Message OptString `json:"message"` + Type OptString `json:"type"` +} + +// GetMessage returns the value of Message. +func (s *PostCocoonQueryUnauthorizedError) GetMessage() OptString { + return s.Message +} + +// GetType returns the value of Type. +func (s *PostCocoonQueryUnauthorizedError) GetType() OptString { + return s.Type +} + +// SetMessage sets the value of Message. +func (s *PostCocoonQueryUnauthorizedError) SetMessage(val OptString) { + s.Message = val +} + +// SetType sets the value of Type. +func (s *PostCocoonQueryUnauthorizedError) SetType(val OptString) { + s.Type = val +} + +type PostCocoonV1ChatCompletionsNotImplemented struct{} + +func (*PostCocoonV1ChatCompletionsNotImplemented) postCocoonV1ChatCompletionsRes() {} + +type PostCocoonV1ChatCompletionsOKApplicationJSON jx.Raw + +func (*PostCocoonV1ChatCompletionsOKApplicationJSON) postCocoonV1ChatCompletionsRes() {} + +type PostCocoonV1ChatCompletionsUnauthorized struct { + Error OptPostCocoonV1ChatCompletionsUnauthorizedError `json:"error"` +} + +// GetError returns the value of Error. +func (s *PostCocoonV1ChatCompletionsUnauthorized) GetError() OptPostCocoonV1ChatCompletionsUnauthorizedError { + return s.Error +} + +// SetError sets the value of Error. +func (s *PostCocoonV1ChatCompletionsUnauthorized) SetError(val OptPostCocoonV1ChatCompletionsUnauthorizedError) { + s.Error = val +} + +func (*PostCocoonV1ChatCompletionsUnauthorized) postCocoonV1ChatCompletionsRes() {} + +type PostCocoonV1ChatCompletionsUnauthorizedError struct { + Message OptString `json:"message"` + Type OptString `json:"type"` +} + +// GetMessage returns the value of Message. +func (s *PostCocoonV1ChatCompletionsUnauthorizedError) GetMessage() OptString { + return s.Message +} + +// GetType returns the value of Type. +func (s *PostCocoonV1ChatCompletionsUnauthorizedError) GetType() OptString { + return s.Type +} + +// SetMessage sets the value of Message. +func (s *PostCocoonV1ChatCompletionsUnauthorizedError) SetMessage(val OptString) { + s.Message = val +} + +// SetType sets the value of Type. +func (s *PostCocoonV1ChatCompletionsUnauthorizedError) SetType(val OptString) { + s.Type = val +} + // Ref: #/components/schemas/Price type Price struct { CurrencyType CurrencyType `json:"currency_type"` diff --git a/pkg/oas/oas_server_gen.go b/pkg/oas/oas_server_gen.go index c90b10b6..1a060f57 100644 --- a/pkg/oas/oas_server_gen.go +++ b/pkg/oas/oas_server_gen.go @@ -327,6 +327,12 @@ type Handler interface { // // GET /v2/rates/chart GetChartRates(ctx context.Context, params GetChartRatesParams) (*GetChartRatesOK, error) + // GetCocoonWorkers implements getCocoonWorkers operation. + // + // Cocoon worker types (same shape as gocoon Connection.GetWorkerTypes). + // + // GET /v2/cocoon/workers + GetCocoonWorkers(ctx context.Context) (GetCocoonWorkersRes, error) // GetDnsInfo implements getDnsInfo operation. // // Get full information about domain name. @@ -668,6 +674,19 @@ type Handler interface { // // POST /v2/pubkeys/wallets/_bulk GetWalletsByPublicKeyBulk(ctx context.Context, req OptGetWalletsByPublicKeyBulkReq) (*WalletsByPublicKeys, error) + // PostCocoonQuery implements postCocoonQuery operation. + // + // Proxy arbitrary OpenAI-style JSON to Cocoon (POST). + // + // POST /v2/cocoon/query + PostCocoonQuery(ctx context.Context, req jx.Raw, params PostCocoonQueryParams) (PostCocoonQueryRes, error) + // PostCocoonV1ChatCompletions implements postCocoonV1ChatCompletions operation. + // + // OpenAI-compatible [Create chat completion](https://developers.openai. + // com/api/reference/resources/chat/subresources/completions/methods/create). + // + // POST /v2/cocoon/v1/chat/completions + PostCocoonV1ChatCompletions(ctx context.Context, req jx.Raw) (PostCocoonV1ChatCompletionsRes, error) // ReindexAccount implements reindexAccount operation. // // Update internal cache for a particular account. diff --git a/pkg/oas/oas_unimplemented_gen.go b/pkg/oas/oas_unimplemented_gen.go index 4abc549a..020497ea 100644 --- a/pkg/oas/oas_unimplemented_gen.go +++ b/pkg/oas/oas_unimplemented_gen.go @@ -484,6 +484,15 @@ func (UnimplementedHandler) GetChartRates(ctx context.Context, params GetChartRa return r, ht.ErrNotImplemented } +// GetCocoonWorkers implements getCocoonWorkers operation. +// +// Cocoon worker types (same shape as gocoon Connection.GetWorkerTypes). +// +// GET /v2/cocoon/workers +func (UnimplementedHandler) GetCocoonWorkers(ctx context.Context) (r GetCocoonWorkersRes, _ error) { + return r, ht.ErrNotImplemented +} + // GetDnsInfo implements getDnsInfo operation. // // Get full information about domain name. @@ -990,6 +999,25 @@ func (UnimplementedHandler) GetWalletsByPublicKeyBulk(ctx context.Context, req O return r, ht.ErrNotImplemented } +// PostCocoonQuery implements postCocoonQuery operation. +// +// Proxy arbitrary OpenAI-style JSON to Cocoon (POST). +// +// POST /v2/cocoon/query +func (UnimplementedHandler) PostCocoonQuery(ctx context.Context, req jx.Raw, params PostCocoonQueryParams) (r PostCocoonQueryRes, _ error) { + return r, ht.ErrNotImplemented +} + +// PostCocoonV1ChatCompletions implements postCocoonV1ChatCompletions operation. +// +// OpenAI-compatible [Create chat completion](https://developers.openai. +// com/api/reference/resources/chat/subresources/completions/methods/create). +// +// POST /v2/cocoon/v1/chat/completions +func (UnimplementedHandler) PostCocoonV1ChatCompletions(ctx context.Context, req jx.Raw) (r PostCocoonV1ChatCompletionsRes, _ error) { + return r, ht.ErrNotImplemented +} + // ReindexAccount implements reindexAccount operation. // // Update internal cache for a particular account. diff --git a/pkg/oas/oas_validators_gen.go b/pkg/oas/oas_validators_gen.go index bf277171..c8f94f71 100644 --- a/pkg/oas/oas_validators_gen.go +++ b/pkg/oas/oas_validators_gen.go @@ -2012,6 +2012,161 @@ func (s ChartPoints) Validate() error { return nil } +func (s *CocoonWorkerInstance) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 0, + MaxSet: false, + Max: 0, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(s.Coefficient)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "coefficient", + Error: err, + }) + } + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 0, + MaxSet: false, + Max: 0, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(s.ActiveRequests)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "active_requests", + Error: err, + }) + } + if err := func() error { + if err := (validate.Int{ + MinSet: true, + Min: 0, + MaxSet: false, + Max: 0, + MinExclusive: false, + MaxExclusive: false, + MultipleOfSet: false, + MultipleOf: 0, + Pattern: nil, + }).Validate(int64(s.MaxActiveRequests)); err != nil { + return errors.Wrap(err, "int") + } + return nil + }(); err != nil { + failures = append(failures, validate.FieldError{ + Name: "max_active_requests", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *CocoonWorkerType) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Workers == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.Workers { + 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: "workers", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + +func (s *CocoonWorkersResponse) Validate() error { + if s == nil { + return validate.ErrNilPointer + } + + var failures []validate.FieldError + if err := func() error { + if s.Types == nil { + return errors.New("nil is invalid value") + } + var failures []validate.FieldError + for i, elem := range s.Types { + 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: "types", + Error: err, + }) + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + return nil +} + func (s *ComputePhase) Validate() error { if s == nil { return validate.ErrNilPointer