diff --git a/api/openapi.json b/api/openapi.json index 634c5b94..36b20a72 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": { @@ -7711,6 +7768,139 @@ }, "openapi": "3.0.0", "paths": { + "/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" + } + } + } + }, + "/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/accounts/_bulk": { "post": { "description": "Get human-friendly information about several accounts without low-level details.", diff --git a/api/openapi.yml b/api/openapi.yml index 19053d3f..864f5236 100644 --- a/api/openapi.yml +++ b/api/openapi.yml @@ -3078,6 +3078,90 @@ paths: $ref: "#/components/schemas/RoundRewardsResponse" 'default': $ref: '#/components/responses/Error' + + /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' + + /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' components: parameters: masterchainSeqno: @@ -3651,6 +3735,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 cf5eae6c..e73220ba 100644 --- a/go.mod +++ b/go.mod @@ -22,15 +22,16 @@ 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 v0.0.0-20260417144551-b6d55ffca6ae github.com/tonkeeper/scam_backoffice_rules v0.0.11 - github.com/tonkeeper/tongo v1.18.4 + 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/sync v0.20.0 golang.org/x/text v0.35.0 google.golang.org/grpc v1.80.0 gopkg.in/yaml.v3 v3.0.1 @@ -59,10 +60,10 @@ 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/sync v0.20.0 // indirect golang.org/x/sys v0.42.0 // indirect golang.org/x/tools v0.43.0 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9 // indirect diff --git a/go.sum b/go.sum index bd240642..9839a8bd 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,44 +41,30 @@ 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/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= @@ -103,136 +77,71 @@ 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-20260417144551-b6d55ffca6ae h1:XNzBpvURYjDohMHbjKVeEMptrz7mjNuX635wAgp6xPk= +github.com/tonkeeper/gocoon v0.0.0-20260417144551-b6d55ffca6ae/go.mod h1:PEua00og1/0ywrf0aB3sAcxDSM2G1nbD4t12PFuyAHk= 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.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= +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.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= 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= 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= @@ -240,10 +149,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..ef4caf67 --- /dev/null +++ b/pkg/api/cocoon_handlers.go @@ -0,0 +1,83 @@ +package api + +import ( + "context" + "encoding/json" + "net/http" + + "github.com/go-faster/jx" + gocoon "github.com/tonkeeper/gocoon/pkg/client" + + "github.com/tonkeeper/opentonapi/pkg/oas" +) + +func (h *Handler) PostCocoonQuery(ctx context.Context, req jx.Raw, params oas.PostCocoonQueryParams) (oas.PostCocoonQueryRes, error) { + if h.cocoonPool == nil { + return &oas.PostCocoonQueryNotImplemented{}, nil + } + conn, err := h.cocoonPool.pick(ctx) + if err != nil { + return nil, toError(http.StatusInternalServerError, err) + } + + body := []byte(req) + if len(body) == 0 { + body = []byte("{}") + } + + model := "" + if params.Model.Set { + model = params.Model.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 + } + } + + upstreamPath := params.Path.Value + respBody, err := conn.POST(ctx, model, upstreamPath, body) + if err != nil { + return nil, toError(http.StatusBadGateway, err) + } + + ok := oas.PostCocoonQueryOKApplicationJSON(jx.Raw(respBody)) + return &ok, nil +} + +func (h *Handler) GetCocoonWorkers(ctx context.Context) (oas.GetCocoonWorkersRes, error) { + if h.cocoonPool == nil { + return &oas.GetCocoonWorkersNotImplemented{}, nil + } + conn, err := h.cocoonPool.pick(ctx) + if err != nil { + return nil, toError(http.StatusInternalServerError, err) + } + types, err := conn.GetWorkerTypes(ctx) + if err != nil { + return nil, toError(http.StatusBadGateway, err) + } + return workerTypesToResponse(types), nil +} + +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..da0c5e00 --- /dev/null +++ b/pkg/api/cocoon_pool.go @@ -0,0 +1,70 @@ +package api + +import ( + "context" + "math/rand/v2" + "sync" + + gocoon "github.com/tonkeeper/gocoon/pkg/client" + "go.uber.org/zap" +) + +type CocoonDialer interface { + Connect(ctx context.Context, logger *zap.Logger) (*gocoon.Connection, error) +} + +type CocoonPool struct { + mu sync.Mutex + size int + client CocoonDialer + logger *zap.Logger + conns []*gocoon.Connection +} + +func NewCocoonPool(client CocoonDialer, logger *zap.Logger, size int) *CocoonPool { + if size <= 0 { + size = 3 + } + return &CocoonPool{ + client: client, + logger: logger, + size: size, + conns: make([]*gocoon.Connection, size), + } +} + +func (p *CocoonPool) StartAsync() { + for slot := range p.size { + go func(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() + p.conns[slot] = conn + p.mu.Unlock() + if p.logger != nil { + p.logger.Info("cocoon pool: connection ready", zap.Int("slot", slot)) + } + }(slot) + } +} + +func (p *CocoonPool) pick(ctx context.Context) (*gocoon.Connection, error) { + p.mu.Lock() + ready := make([]*gocoon.Connection, 0, p.size) + for _, c := range p.conns { + if c != nil { + ready = append(ready, c) + } + } + p.mu.Unlock() + 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 bd5c8ba2..3e2a7e0b 100644 --- a/pkg/api/handler.go +++ b/pkg/api/handler.go @@ -51,6 +51,7 @@ type Handler struct { tonConnect *tonconnect.Server verifierSource verifierSource validation *validation.Service + cocoonPool *CocoonPool // parallelTraceProcessing enables parallel trace-to-action conversion. parallelTraceProcessing bool @@ -96,6 +97,7 @@ type Options struct { score scoreSource parallelTraceProcessing bool liteapi *liteapi.Client + cocoonPool *CocoonPool } type Option func(o *Options) @@ -189,6 +191,12 @@ func WithLiteapiClient(client *liteapi.Client) Option { } } +func WithCocoonPool(pool *CocoonPool) Option { + return func(o *Options) { + o.cocoonPool = pool + } +} + func NewHandler(logger *zap.Logger, opts ...Option) (*Handler, error) { options := &Options{} for _, o := range opts { @@ -280,6 +288,7 @@ func NewHandler(logger *zap.Logger, opts ...Option) (*Handler, error) { tonConnect: tonConnect, configPool: configPool, validation: validationService, + cocoonPool: options.cocoonPool, }, nil } diff --git a/pkg/oas/oas_handlers_gen.go b/pkg/oas/oas_handlers_gen.go index 5097ce5a..accac929 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 /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("/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. @@ -16674,6 +16809,179 @@ func (s *Server) handleGetWalletsByPublicKeyBulkRequest(args [0]string, argsEsca } } +// handlePostCocoonQueryRequest handles postCocoonQuery operation. +// +// Proxy arbitrary OpenAI-style JSON to Cocoon (POST). +// +// POST /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("/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 + } +} + // 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..5d143208 --- /dev/null +++ b/pkg/oas/oas_interfaces_gen.go @@ -0,0 +1,10 @@ +// Code generated by ogen, DO NOT EDIT. +package oas + +type GetCocoonWorkersRes interface { + getCocoonWorkersRes() +} + +type PostCocoonQueryRes interface { + postCocoonQueryRes() +} diff --git a/pkg/oas/oas_json_gen.go b/pkg/oas/oas_json_gen.go index de6aa8a9..9015a495 100644 --- a/pkg/oas/oas_json_gen.go +++ b/pkg/oas/oas_json_gen.go @@ -11859,6 +11859,365 @@ func (s *ChartPoints) UnmarshalJSON(data []byte) error { return s.Decode(d) } +// Encode implements json.Marshaler. +func (s *CocoonWorkerInstance) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CocoonWorkerInstance) encodeFields(e *jx.Encoder) { + { + e.FieldStart("coefficient") + e.Int64(s.Coefficient) + } + { + e.FieldStart("active_requests") + e.Int64(s.ActiveRequests) + } + { + e.FieldStart("max_active_requests") + e.Int64(s.MaxActiveRequests) + } +} + +var jsonFieldsNameOfCocoonWorkerInstance = [3]string{ + 0: "coefficient", + 1: "active_requests", + 2: "max_active_requests", +} + +// Decode decodes CocoonWorkerInstance from json. +func (s *CocoonWorkerInstance) Decode(d *jx.Decoder) error { + if s == 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 "coefficient": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + v, err := d.Int64() + s.Coefficient = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"coefficient\"") + } + case "active_requests": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + v, err := d.Int64() + s.ActiveRequests = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"active_requests\"") + } + case "max_active_requests": + requiredBitSet[0] |= 1 << 2 + if err := func() error { + v, err := d.Int64() + s.MaxActiveRequests = int64(v) + if err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"max_active_requests\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CocoonWorkerInstance") + } + // 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(jsonFieldsNameOfCocoonWorkerInstance) { + name = jsonFieldsNameOfCocoonWorkerInstance[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 *CocoonWorkerInstance) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CocoonWorkerInstance) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CocoonWorkerType) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CocoonWorkerType) encodeFields(e *jx.Encoder) { + { + e.FieldStart("name") + e.Str(s.Name) + } + { + e.FieldStart("workers") + e.ArrStart() + for _, elem := range s.Workers { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfCocoonWorkerType = [2]string{ + 0: "name", + 1: "workers", +} + +// Decode decodes CocoonWorkerType from json. +func (s *CocoonWorkerType) Decode(d *jx.Decoder) error { + if s == 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 "name": + requiredBitSet[0] |= 1 << 0 + 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 "workers": + requiredBitSet[0] |= 1 << 1 + if err := func() error { + 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 \"workers\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CocoonWorkerType") + } + // 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(jsonFieldsNameOfCocoonWorkerType) { + name = jsonFieldsNameOfCocoonWorkerType[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 *CocoonWorkerType) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CocoonWorkerType) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *CocoonWorkersResponse) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +func (s *CocoonWorkersResponse) encodeFields(e *jx.Encoder) { + { + e.FieldStart("types") + e.ArrStart() + for _, elem := range s.Types { + elem.Encode(e) + } + e.ArrEnd() + } +} + +var jsonFieldsNameOfCocoonWorkersResponse = [1]string{ + 0: "types", +} + +// Decode decodes CocoonWorkersResponse from json. +func (s *CocoonWorkersResponse) Decode(d *jx.Decoder) error { + if s == 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 "types": + requiredBitSet[0] |= 1 << 0 + if err := func() error { + s.Types = make([]CocoonWorkerType, 0) + if err := d.Arr(func(d *jx.Decoder) error { + var elem CocoonWorkerType + if err := elem.Decode(d); err != nil { + return err + } + s.Types = append(s.Types, elem) + return nil + }); err != nil { + return err + } + return nil + }(); err != nil { + return errors.Wrap(err, "decode field \"types\"") + } + default: + return d.Skip() + } + return nil + }); err != nil { + return errors.Wrap(err, "decode CocoonWorkersResponse") + } + // 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(jsonFieldsNameOfCocoonWorkersResponse) { + name = jsonFieldsNameOfCocoonWorkersResponse[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 *CocoonWorkersResponse) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *CocoonWorkersResponse) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode implements json.Marshaler. func (s *ComputePhase) Encode(e *jx.Encoder) { e.ObjStart() @@ -19226,31 +19585,218 @@ func (s *GetChartRatesOK) Decode(d *jx.Decoder) error { } 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 + } + } + } + if len(failures) > 0 { + return &validate.Error{Fields: failures} + } + + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s *GetChartRatesOK) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *GetChartRatesOK) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + +// Encode implements json.Marshaler. +func (s *GetCocoonWorkersNotImplemented) Encode(e *jx.Encoder) { + e.ObjStart() + s.encodeFields(e) + e.ObjEnd() +} + +// encodeFields encodes fields. +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) { + { + if s.Error.Set { + e.FieldStart("error") + s.Error.Encode(e) + } + } +} + +var jsonFieldsNameOfGetCocoonWorkersUnauthorized = [1]string{ + 0: "error", +} + +// Decode decodes GetCocoonWorkersUnauthorized from json. +func (s *GetCocoonWorkersUnauthorized) Decode(d *jx.Decoder) error { + if s == nil { + return errors.New("invalid: unable to decode GetCocoonWorkersUnauthorized 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 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() } - } - if len(failures) > 0 { - return &validate.Error{Fields: failures} + return nil + }); err != nil { + return errors.Wrap(err, "decode GetCocoonWorkersUnauthorizedError") } return nil } // MarshalJSON implements stdjson.Marshaler. -func (s *GetChartRatesOK) MarshalJSON() ([]byte, error) { +func (s *GetCocoonWorkersUnauthorizedError) 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 *GetCocoonWorkersUnauthorizedError) UnmarshalJSON(data []byte) error { d := jx.DecodeBytes(data) return s.Decode(d) } @@ -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 { @@ -34562,6 +35141,39 @@ func (s *OptPictureDNS) UnmarshalJSON(data []byte) error { 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 PostCocoonQueryUnauthorizedError from json. +func (o *OptPostCocoonQueryUnauthorizedError) Decode(d *jx.Decoder) error { + if o == nil { + return errors.New("invalid: unable to decode OptPostCocoonQueryUnauthorizedError to nil") + } + o.Set = true + if err := o.Value.Decode(d); err != nil { + return err + } + return nil +} + +// MarshalJSON implements stdjson.Marshaler. +func (s OptPostCocoonQueryUnauthorizedError) MarshalJSON() ([]byte, error) { + e := jx.Encoder{} + s.Encode(&e) + return e.Bytes(), nil +} + +// UnmarshalJSON implements stdjson.Unmarshaler. +func (s *OptPostCocoonQueryUnauthorizedError) UnmarshalJSON(data []byte) error { + d := jx.DecodeBytes(data) + return s.Decode(d) +} + // Encode encodes Price as json. func (o OptPrice) Encode(e *jx.Encoder) { if !o.Set { @@ -36467,6 +37079,235 @@ func (s *PoolInfo) UnmarshalJSON(data []byte) error { 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 \"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 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 *Price) Encode(e *jx.Encoder) { e.ObjStart() diff --git a/pkg/oas/oas_operations_gen.go b/pkg/oas/oas_operations_gen.go index f80b2e8b..9c0c0c35 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,7 @@ const ( GetWalletInfoOperation OperationName = "GetWalletInfo" GetWalletsByPublicKeyOperation OperationName = "GetWalletsByPublicKey" GetWalletsByPublicKeyBulkOperation OperationName = "GetWalletsByPublicKeyBulk" + PostCocoonQueryOperation OperationName = "PostCocoonQuery" 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 9f6a5de0..9ea5ad98 100644 --- a/pkg/oas/oas_parameters_gen.go +++ b/pkg/oas/oas_parameters_gen.go @@ -12366,6 +12366,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..a53d5993 100644 --- a/pkg/oas/oas_request_decoders_gen.go +++ b/pkg/oas/oas_request_decoders_gen.go @@ -1130,6 +1130,79 @@ 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) decodeSendBlockchainMessageRequest(r *http.Request) ( req *SendBlockchainMessageReq, rawBody []byte, diff --git a/pkg/oas/oas_response_encoders_gen.go b/pkg/oas/oas_response_encoders_gen.go index 6708a821..24664752 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,52 @@ 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 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 6b1aa65d..fc1236e4 100644 --- a/pkg/oas/oas_router_gen.go +++ b/pkg/oas/oas_router_gen.go @@ -11,6 +11,9 @@ import ( ) var ( + rn192AllowedHeaders = map[string]string{ + "POST": "Content-Type", + } rn63AllowedHeaders = map[string]string{ "POST": "Content-Type", } @@ -35,16 +38,16 @@ var ( rn27AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn191AllowedHeaders = map[string]string{ + rn195AllowedHeaders = map[string]string{ "POST": "Content-Type", } rn22AllowedHeaders = map[string]string{ "POST": "Accept-Language,Content-Type", } - rn91AllowedHeaders = map[string]string{ + rn93AllowedHeaders = map[string]string{ "GET": "Accept-Language", } - rn110AllowedHeaders = map[string]string{ + rn112AllowedHeaders = map[string]string{ "GET": "Accept-Language", } rn31AllowedHeaders = map[string]string{ @@ -53,31 +56,31 @@ var ( rn32AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn105AllowedHeaders = map[string]string{ + rn107AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn192AllowedHeaders = map[string]string{ + rn196AllowedHeaders = map[string]string{ "POST": "Content-Type", } rn12AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn125AllowedHeaders = map[string]string{ + rn127AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn120AllowedHeaders = map[string]string{ + rn122AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn124AllowedHeaders = map[string]string{ + rn126AllowedHeaders = map[string]string{ "GET": "Accept-Language", } - rn188AllowedHeaders = map[string]string{ + rn190AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn170AllowedHeaders = map[string]string{ + rn172AllowedHeaders = map[string]string{ "GET": "Accept-Language", } - rn173AllowedHeaders = map[string]string{ + rn175AllowedHeaders = map[string]string{ "GET": "Accept-Language", } rn45AllowedHeaders = map[string]string{ @@ -86,7 +89,7 @@ var ( rn23AllowedHeaders = map[string]string{ "POST": "Content-Type", } - rn195AllowedHeaders = map[string]string{ + rn199AllowedHeaders = map[string]string{ "POST": "Content-Type", } rn24AllowedHeaders = map[string]string{ @@ -133,9 +136,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case '/': // Prefix: "/v2/" + case '/': // Prefix: "/" - if l := len("/v2/"); len(elem) >= l && elem[0:l] == "/v2/" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break @@ -145,9 +148,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'a': // Prefix: "a" + case 'c': // Prefix: "cocoon/" - if l := len("a"); len(elem) >= l && elem[0:l] == "a" { + if l := len("cocoon/"); len(elem) >= l && elem[0:l] == "cocoon/" { elem = elem[l:] } else { break @@ -157,86 +160,44 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'c': // Prefix: "ccounts/" + case 'q': // Prefix: "query" - if l := len("ccounts/"); len(elem) >= l && elem[0:l] == "ccounts/" { + if l := len("query"); len(elem) >= l && elem[0:l] == "query" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case '_': // Prefix: "_bulk" - origElem := elem - if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleGetAccountsRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn63AllowedHeaders, - acceptPost: "application/json", - acceptPatch: "", - }) - } - - return - } - - elem = origElem - case 's': // Prefix: "search" - origElem := elem - if l := len("search"); len(elem) >= l && elem[0:l] == "search" { - elem = elem[l:] - } else { - break + // 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: "", + }) } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleSearchAccountsRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } + return + } - return - } + case 'w': // Prefix: "workers" - elem = origElem - } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) + if l := len("workers"); len(elem) >= l && elem[0:l] == "workers" { + elem = elem[l:] + } else { + break } - args[0] = elem[:idx] - elem = elem[idx:] if len(elem) == 0 { + // Leaf node. switch r.Method { case "GET": - s.handleGetAccountRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) + s.handleGetCocoonWorkersRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -248,10 +209,36 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } + + } + + case 'v': // Prefix: "v2/" + + if l := len("v2/"); len(elem) >= l && elem[0:l] == "v2/" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "a" + + if l := len("a"); len(elem) >= l && elem[0:l] == "a" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } switch elem[0] { - case '/': // Prefix: "/" + case 'c': // Prefix: "ccounts/" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + if l := len("ccounts/"); len(elem) >= l && elem[0:l] == "ccounts/" { elem = elem[l:] } else { break @@ -261,48 +248,101 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'd': // Prefix: "d" - - if l := len("d"); len(elem) >= l && elem[0:l] == "d" { + case '_': // Prefix: "_bulk" + origElem := elem + if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleGetAccountsRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn63AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } + + return + } + + elem = origElem + case 's': // Prefix: "search" + origElem := elem + if l := len("search"); len(elem) >= l && elem[0:l] == "search" { + elem = elem[l:] + } else { break } - switch elem[0] { - case 'i': // Prefix: "iff" - if l := len("iff"); len(elem) >= l && elem[0:l] == "iff" { - elem = elem[l:] - } else { - break + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleSearchAccountsRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetAccountDiffRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } + return + } - return - } + elem = origElem + } + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + switch r.Method { + case "GET": + s.handleGetAccountRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + switch elem[0] { + case '/': // Prefix: "/" + + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } - case 'n': // Prefix: "ns/" + if len(elem) == 0 { + break + } + switch elem[0] { + case 'd': // Prefix: "d" - if l := len("ns/"); len(elem) >= l && elem[0:l] == "ns/" { + if l := len("d"); len(elem) >= l && elem[0:l] == "d" { elem = elem[l:] } else { break @@ -312,9 +352,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'b': // Prefix: "backresolve" + case 'i': // Prefix: "iff" - if l := len("backresolve"); len(elem) >= l && elem[0:l] == "backresolve" { + if l := len("iff"); len(elem) >= l && elem[0:l] == "iff" { elem = elem[l:] } else { break @@ -324,7 +364,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleAccountDnsBackResolveRequest([1]string{ + s.handleGetAccountDiffRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: @@ -339,67 +379,257 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - case 'e': // Prefix: "expiring" + case 'n': // Prefix: "ns/" - if l := len("expiring"); len(elem) >= l && elem[0:l] == "expiring" { + if l := len("ns/"); len(elem) >= l && elem[0:l] == "ns/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetAccountDnsExpiringRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return + break } + switch elem[0] { + case 'b': // Prefix: "backresolve" - } - - } + if l := len("backresolve"); len(elem) >= l && elem[0:l] == "backresolve" { + elem = elem[l:] + } else { + break + } - case 'e': // Prefix: "e" + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleAccountDnsBackResolveRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - if l := len("e"); len(elem) >= l && elem[0:l] == "e" { - elem = elem[l:] - } else { - break - } + return + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'v': // Prefix: "vents" + case 'e': // Prefix: "expiring" - if l := len("vents"); len(elem) >= l && elem[0:l] == "vents" { - elem = elem[l:] - } else { - break - } + if l := len("expiring"); len(elem) >= l && elem[0:l] == "expiring" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - switch r.Method { + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetAccountDnsExpiringRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } + + } + + case 'e': // Prefix: "e" + + if l := len("e"); len(elem) >= l && elem[0:l] == "e" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'v': // Prefix: "vents" + + if l := len("vents"); len(elem) >= l && elem[0:l] == "vents" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "GET": + s.handleGetAccountEventsRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: rn39AllowedHeaders, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + switch elem[0] { + case '/': // Prefix: "/" + + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'e': // Prefix: "emulate" + origElem := elem + if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleEmulateMessageToAccountEventRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn21AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } + + return + } + + elem = origElem + } + // Param: "event_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[1] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetAccountEventRequest([2]string{ + args[0], + args[1], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: rn38AllowedHeaders, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } + + case 'x': // Prefix: "xtra-currency/" + + if l := len("xtra-currency/"); len(elem) >= l && elem[0:l] == "xtra-currency/" { + elem = elem[l:] + } else { + break + } + + // Param: "id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[1] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + break + } + switch elem[0] { + case '/': // Prefix: "/history" + + if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetAccountExtraCurrencyHistoryByIDRequest([2]string{ + args[0], + args[1], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: rn43AllowedHeaders, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } + + } + + case 'j': // Prefix: "jettons" + + if l := len("jettons"); len(elem) >= l && elem[0:l] == "jettons" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { case "GET": - s.handleGetAccountEventsRequest([1]string{ + s.handleGetAccountJettonsBalancesRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", - allowedHeaders: rn39AllowedHeaders, + allowedHeaders: nil, acceptPost: "", acceptPatch: "", }) @@ -420,9 +650,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'e': // Prefix: "emulate" + case 'h': // Prefix: "history" origElem := elem - if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { + if l := len("history"); len(elem) >= l && elem[0:l] == "history" { elem = elem[l:] } else { break @@ -431,15 +661,15 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { // Leaf node. switch r.Method { - case "POST": - s.handleEmulateMessageToAccountEventRequest([1]string{ + case "GET": + s.handleGetAccountJettonsHistoryRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn21AllowedHeaders, - acceptPost: "application/json", + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", acceptPatch: "", }) } @@ -449,27 +679,26 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { elem = origElem } - // Param: "event_id" - // Leaf parameter, slashes are prohibited + // Param: "jetton_id" + // Match until "/" idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break + if idx < 0 { + idx = len(elem) } - args[1] = elem - elem = "" + args[1] = elem[:idx] + elem = elem[idx:] if len(elem) == 0 { - // Leaf node. switch r.Method { case "GET": - s.handleGetAccountEventRequest([2]string{ + s.handleGetAccountJettonBalanceRequest([2]string{ args[0], args[1], }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", - allowedHeaders: rn38AllowedHeaders, + allowedHeaders: nil, acceptPost: "", acceptPatch: "", }) @@ -477,29 +706,91 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } + switch elem[0] { + case '/': // Prefix: "/history" + + if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetAccountJettonHistoryByIDRequest([2]string{ + args[0], + args[1], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: rn48AllowedHeaders, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } } - case 'x': // Prefix: "xtra-currency/" + case 'm': // Prefix: "multisigs" - if l := len("xtra-currency/"); len(elem) >= l && elem[0:l] == "xtra-currency/" { + if l := len("multisigs"); len(elem) >= l && elem[0:l] == "multisigs" { elem = elem[l:] } else { break } - // Param: "id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetAccountMultisigsRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return } - args[1] = elem[:idx] - elem = elem[idx:] - if len(elem) == 0 { + case 'n': // Prefix: "nfts" + + if l := len("nfts"); len(elem) >= l && elem[0:l] == "nfts" { + elem = elem[l:] + } else { break } + + if len(elem) == 0 { + switch r.Method { + case "GET": + s.handleGetAccountNftItemsRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } switch elem[0] { case '/': // Prefix: "/history" @@ -513,14 +804,13 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetAccountExtraCurrencyHistoryByIDRequest([2]string{ + s.handleGetAccountNftHistoryRequest([1]string{ args[0], - args[1], }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", - allowedHeaders: rn43AllowedHeaders, + allowedHeaders: rn52AllowedHeaders, acceptPost: "", acceptPatch: "", }) @@ -531,90 +821,20 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } - } - - case 'j': // Prefix: "jettons" - - if l := len("jettons"); len(elem) >= l && elem[0:l] == "jettons" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetAccountJettonsBalancesRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - switch elem[0] { - case '/': // Prefix: "/" + case 'p': // Prefix: "publickey" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + if l := len("publickey"); len(elem) >= l && elem[0:l] == "publickey" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'h': // Prefix: "history" - origElem := elem - if l := len("history"); len(elem) >= l && elem[0:l] == "history" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetAccountJettonsHistoryRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - elem = origElem - } - // Param: "jetton_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[1] = elem[:idx] - elem = elem[idx:] - - if len(elem) == 0 { + // Leaf node. switch r.Method { case "GET": - s.handleGetAccountJettonBalanceRequest([2]string{ + s.handleGetAccountPublicKeyRequest([1]string{ args[0], - args[1], }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ @@ -627,95 +847,37 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - switch elem[0] { - case '/': // Prefix: "/history" - - if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetAccountJettonHistoryByIDRequest([2]string{ - args[0], - args[1], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: rn48AllowedHeaders, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - } - - } - - case 'm': // Prefix: "multisigs" - if l := len("multisigs"); len(elem) >= l && elem[0:l] == "multisigs" { - elem = elem[l:] - } else { - break - } + case 'r': // Prefix: "reindex" - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetAccountMultisigsRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + if l := len("reindex"); len(elem) >= l && elem[0:l] == "reindex" { + elem = elem[l:] + } else { + break } - return - } - - case 'n': // Prefix: "nfts" - - if l := len("nfts"); len(elem) >= l && elem[0:l] == "nfts" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleReindexAccountRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetAccountNftItemsRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + return } - return - } - switch elem[0] { - case '/': // Prefix: "/history" + case 's': // Prefix: "subscriptions" - if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + if l := len("subscriptions"); len(elem) >= l && elem[0:l] == "subscriptions" { elem = elem[l:] } else { break @@ -725,13 +887,13 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetAccountNftHistoryRequest([1]string{ + s.handleGetAccountSubscriptionsRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", - allowedHeaders: rn52AllowedHeaders, + allowedHeaders: nil, acceptPost: "", acceptPatch: "", }) @@ -740,92 +902,61 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - } - - case 'p': // Prefix: "publickey" - - if l := len("publickey"); len(elem) >= l && elem[0:l] == "publickey" { - elem = elem[l:] - } else { - break - } + case 't': // Prefix: "traces" - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetAccountPublicKeyRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + if l := len("traces"); len(elem) >= l && elem[0:l] == "traces" { + elem = elem[l:] + } else { + break } - return - } - - case 'r': // Prefix: "reindex" - - if l := len("reindex"); len(elem) >= l && elem[0:l] == "reindex" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetAccountTracesRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleReindexAccountRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + return } - return } - case 's': // Prefix: "subscriptions" + } - if l := len("subscriptions"); len(elem) >= l && elem[0:l] == "subscriptions" { - elem = elem[l:] - } else { - break - } + case 'd': // Prefix: "ddress/" - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetAccountSubscriptionsRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } + if l := len("ddress/"); len(elem) >= l && elem[0:l] == "ddress/" { + elem = elem[l:] + } else { + break + } - return - } + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] - case 't': // Prefix: "traces" + if len(elem) == 0 { + break + } + switch elem[0] { + case '/': // Prefix: "/parse" - if l := len("traces"); len(elem) >= l && elem[0:l] == "traces" { + if l := len("/parse"); len(elem) >= l && elem[0:l] == "/parse" { elem = elem[l:] } else { break @@ -835,7 +966,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetAccountTracesRequest([1]string{ + s.handleAddressParseRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: @@ -854,40 +985,39 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } - case 'd': // Prefix: "ddress/" + case 'b': // Prefix: "blockchain/" - if l := len("ddress/"); len(elem) >= l && elem[0:l] == "ddress/" { + if l := len("blockchain/"); len(elem) >= l && elem[0:l] == "blockchain/" { elem = elem[l:] } else { break } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] - if len(elem) == 0 { break } switch elem[0] { - case '/': // Prefix: "/parse" + case 'a': // Prefix: "accounts/" - if l := len("/parse"); len(elem) >= l && elem[0:l] == "/parse" { + if l := len("accounts/"); len(elem) >= l && elem[0:l] == "accounts/" { elem = elem[l:] } else { break } + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + if len(elem) == 0 { - // Leaf node. switch r.Method { case "GET": - s.handleAddressParseRequest([1]string{ + s.handleGetBlockchainRawAccountRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: @@ -901,142 +1031,251 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } + switch elem[0] { + case '/': // Prefix: "/" - } - - } + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } - case 'b': // Prefix: "blockchain/" + if len(elem) == 0 { + break + } + switch elem[0] { + case 'i': // Prefix: "inspect" - if l := len("blockchain/"); len(elem) >= l && elem[0:l] == "blockchain/" { - elem = elem[l:] - } else { - break - } + if l := len("inspect"); len(elem) >= l && elem[0:l] == "inspect" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "accounts/" + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleBlockchainAccountInspectRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - if l := len("accounts/"); len(elem) >= l && elem[0:l] == "accounts/" { - elem = elem[l:] - } else { - break - } + return + } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] + case 'm': // Prefix: "methods/" + + if l := len("methods/"); len(elem) >= l && elem[0:l] == "methods/" { + elem = elem[l:] + } else { + break + } + + // Param: "method_name" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[1] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleExecGetMethodForBlockchainAccountRequest([2]string{ + args[0], + args[1], + }, elemIsEscaped, w, r) + case "POST": + s.handleExecGetMethodWithBodyForBlockchainAccountRequest([2]string{ + args[0], + args[1], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET,POST", + allowedHeaders: rn27AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } + + return + } + + case 't': // Prefix: "transactions" + + if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetBlockchainAccountTransactionsRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetBlockchainRawAccountRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) } - return - } - switch elem[0] { - case '/': // Prefix: "/" + case 'b': // Prefix: "blocks/" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + if l := len("blocks/"); len(elem) >= l && elem[0:l] == "blocks/" { elem = elem[l:] } else { break } + // Param: "block_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + if len(elem) == 0 { - break + switch r.Method { + case "GET": + s.handleGetBlockchainBlockRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return } switch elem[0] { - case 'i': // Prefix: "inspect" + case '/': // Prefix: "/" - if l := len("inspect"); len(elem) >= l && elem[0:l] == "inspect" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleBlockchainAccountInspectRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + break + } + switch elem[0] { + case 'b': // Prefix: "boc" + + if l := len("boc"); len(elem) >= l && elem[0:l] == "boc" { + elem = elem[l:] + } else { + break } - return - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleDownloadBlockchainBlockBocRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - case 'm': // Prefix: "methods/" + return + } - if l := len("methods/"); len(elem) >= l && elem[0:l] == "methods/" { - elem = elem[l:] - } else { - break - } + case 't': // Prefix: "transactions" - // Param: "method_name" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[1] = elem - elem = "" + if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleExecGetMethodForBlockchainAccountRequest([2]string{ - args[0], - args[1], - }, elemIsEscaped, w, r) - case "POST": - s.handleExecGetMethodWithBodyForBlockchainAccountRequest([2]string{ - args[0], - args[1], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET,POST", - allowedHeaders: rn27AllowedHeaders, - acceptPost: "application/json", - acceptPatch: "", - }) + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetBlockchainBlockTransactionsRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return } - return } - case 't': // Prefix: "transactions" + } + + case 'c': // Prefix: "config" + + if l := len("config"); len(elem) >= l && elem[0:l] == "config" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "GET": + s.handleGetBlockchainConfigRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + switch elem[0] { + case '/': // Prefix: "/raw" - if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" { + if l := len("/raw"); len(elem) >= l && elem[0:l] == "/raw" { elem = elem[l:] } else { break @@ -1046,9 +1285,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetBlockchainAccountTransactionsRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) + s.handleGetRawBlockchainConfigRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -1063,150 +1300,30 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } - } + case 'l': // Prefix: "libraries/" - case 'b': // Prefix: "blocks/" + if l := len("libraries/"); len(elem) >= l && elem[0:l] == "libraries/" { + elem = elem[l:] + } else { + break + } - if l := len("blocks/"); len(elem) >= l && elem[0:l] == "blocks/" { - elem = elem[l:] - } else { - break - } - - // Param: "block_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] - - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetBlockchainBlockRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - switch elem[0] { - case '/': // Prefix: "/" - - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'b': // Prefix: "boc" - - if l := len("boc"); len(elem) >= l && elem[0:l] == "boc" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleDownloadBlockchainBlockBocRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - case 't': // Prefix: "transactions" - - if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetBlockchainBlockTransactionsRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - } - - } - - case 'c': // Prefix: "config" - - if l := len("config"); len(elem) >= l && elem[0:l] == "config" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetBlockchainConfigRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - switch elem[0] { - case '/': // Prefix: "/raw" - - if l := len("/raw"); len(elem) >= l && elem[0:l] == "/raw" { - elem = elem[l:] - } else { - break - } + // Param: "hash" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" if len(elem) == 0 { // Leaf node. switch r.Method { case "GET": - s.handleGetRawBlockchainConfigRequest([0]string{}, elemIsEscaped, w, r) + s.handleGetLibraryByHashRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -1219,59 +1336,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - } - - case 'l': // Prefix: "libraries/" - - if l := len("libraries/"); len(elem) >= l && elem[0:l] == "libraries/" { - elem = elem[l:] - } else { - break - } - - // Param: "hash" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetLibraryByHashRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - case 'm': // Prefix: "m" - - if l := len("m"); len(elem) >= l && elem[0:l] == "m" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "asterchain" + case 'm': // Prefix: "m" - if l := len("asterchain"); len(elem) >= l && elem[0:l] == "asterchain" { + if l := len("m"); len(elem) >= l && elem[0:l] == "m" { elem = elem[l:] } else { break @@ -1281,52 +1348,43 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case '-': // Prefix: "-head" + case 'a': // Prefix: "asterchain" - if l := len("-head"); len(elem) >= l && elem[0:l] == "-head" { + if l := len("asterchain"); len(elem) >= l && elem[0:l] == "asterchain" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetBlockchainMasterchainHeadRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return + break } + switch elem[0] { + case '-': // Prefix: "-head" - case '/': // Prefix: "/" + if l := len("-head"); len(elem) >= l && elem[0:l] == "-head" { + elem = elem[l:] + } else { + break + } - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetBlockchainMasterchainHeadRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - // Param: "masterchain_seqno" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] + return + } - if len(elem) == 0 { - break - } - switch elem[0] { case '/': // Prefix: "/" if l := len("/"); len(elem) >= l && elem[0:l] == "/" { @@ -1335,66 +1393,34 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } + // Param: "masterchain_seqno" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + if len(elem) == 0 { break } switch elem[0] { - case 'b': // Prefix: "blocks" + case '/': // Prefix: "/" - if l := len("blocks"); len(elem) >= l && elem[0:l] == "blocks" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetBlockchainMasterchainBlocksRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - case 'c': // Prefix: "config" - - if l := len("config"); len(elem) >= l && elem[0:l] == "config" { - elem = elem[l:] - } else { break } - - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetBlockchainConfigFromBlockRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } switch elem[0] { - case '/': // Prefix: "/raw" + case 'b': // Prefix: "blocks" - if l := len("/raw"); len(elem) >= l && elem[0:l] == "/raw" { + if l := len("blocks"); len(elem) >= l && elem[0:l] == "blocks" { elem = elem[l:] } else { break @@ -1404,7 +1430,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetRawBlockchainConfigFromBlockRequest([1]string{ + s.handleGetBlockchainMasterchainBlocksRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: @@ -1419,38 +1445,169 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - } + case 'c': // Prefix: "config" - case 's': // Prefix: "shards" + if l := len("config"); len(elem) >= l && elem[0:l] == "config" { + elem = elem[l:] + } else { + break + } - if l := len("shards"); len(elem) >= l && elem[0:l] == "shards" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + switch r.Method { + case "GET": + s.handleGetBlockchainConfigFromBlockRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetBlockchainMasterchainShardsRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + return + } + switch elem[0] { + case '/': // Prefix: "/raw" + + if l := len("/raw"); len(elem) >= l && elem[0:l] == "/raw" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetRawBlockchainConfigFromBlockRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } + + case 's': // Prefix: "shards" + + if l := len("shards"); len(elem) >= l && elem[0:l] == "shards" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetBlockchainMasterchainShardsRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + case 't': // Prefix: "transactions" + + if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetBlockchainMasterchainTransactionsRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return } - return } - case 't': // Prefix: "transactions" + } + + } + + case 'e': // Prefix: "essage" + + if l := len("essage"); len(elem) >= l && elem[0:l] == "essage" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch r.Method { + case "POST": + s.handleSendBlockchainMessageRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn195AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } + + return + } + switch elem[0] { + case 's': // Prefix: "s/" + + if l := len("s/"); len(elem) >= l && elem[0:l] == "s/" { + elem = elem[l:] + } else { + break + } + + // Param: "msg_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + break + } + switch elem[0] { + case '/': // Prefix: "/transaction" - if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" { + if l := len("/transaction"); len(elem) >= l && elem[0:l] == "/transaction" { elem = elem[l:] } else { break @@ -1460,7 +1617,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetBlockchainMasterchainTransactionsRequest([1]string{ + s.handleGetBlockchainTransactionByMessageHashRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: @@ -1481,131 +1638,146 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } - case 'e': // Prefix: "essage" + case 'r': // Prefix: "reduced/blocks" - if l := len("essage"); len(elem) >= l && elem[0:l] == "essage" { + if l := len("reduced/blocks"); len(elem) >= l && elem[0:l] == "reduced/blocks" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch r.Method { - case "POST": - s.handleSendBlockchainMessageRequest([0]string{}, elemIsEscaped, w, r) + case "GET": + s.handleGetReducedBlockchainBlocksRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn191AllowedHeaders, - acceptPost: "application/json", + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", acceptPatch: "", }) } return } - switch elem[0] { - case 's': // Prefix: "s/" - if l := len("s/"); len(elem) >= l && elem[0:l] == "s/" { - elem = elem[l:] - } else { - break - } + case 't': // Prefix: "transactions/" - // Param: "msg_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] + if l := len("transactions/"); len(elem) >= l && elem[0:l] == "transactions/" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break + // Param: "transaction_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetBlockchainTransactionRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) } - switch elem[0] { - case '/': // Prefix: "/transaction" - if l := len("/transaction"); len(elem) >= l && elem[0:l] == "/transaction" { - elem = elem[l:] - } else { - break - } + return + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetBlockchainTransactionByMessageHashRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } + case 'v': // Prefix: "validators" - return - } + if l := len("validators"); len(elem) >= l && elem[0:l] == "validators" { + elem = elem[l:] + } else { + break + } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetBlockchainValidatorsRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) } + return } } - case 'r': // Prefix: "reduced/blocks" + case 'd': // Prefix: "dns/" - if l := len("reduced/blocks"); len(elem) >= l && elem[0:l] == "reduced/blocks" { + if l := len("dns/"); len(elem) >= l && elem[0:l] == "dns/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetReducedBlockchainBlocksRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + break + } + switch elem[0] { + case 'a': // Prefix: "auctions" + origElem := elem + if l := len("auctions"); len(elem) >= l && elem[0:l] == "auctions" { + elem = elem[l:] + } else { + break } - return - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetAllAuctionsRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - case 't': // Prefix: "transactions/" + return + } - if l := len("transactions/"); len(elem) >= l && elem[0:l] == "transactions/" { - elem = elem[l:] - } else { - break + elem = origElem } - - // Param: "transaction_id" - // Leaf parameter, slashes are prohibited + // Param: "domain_name" + // Match until "/" idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break + if idx < 0 { + idx = len(elem) } - args[0] = elem - elem = "" + args[0] = elem[:idx] + elem = elem[idx:] if len(elem) == 0 { - // Leaf node. switch r.Method { case "GET": - s.handleGetBlockchainTransactionRequest([1]string{ + s.handleGetDnsInfoRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: @@ -1619,103 +1791,80 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } + switch elem[0] { + case '/': // Prefix: "/" - case 'v': // Prefix: "validators" - - if l := len("validators"); len(elem) >= l && elem[0:l] == "validators" { - elem = elem[l:] - } else { - break - } + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetBlockchainValidatorsRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + if len(elem) == 0 { + break } + switch elem[0] { + case 'b': // Prefix: "bids" - return - } + if l := len("bids"); len(elem) >= l && elem[0:l] == "bids" { + elem = elem[l:] + } else { + break + } - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetDomainBidsRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - case 'd': // Prefix: "dns/" + return + } - if l := len("dns/"); len(elem) >= l && elem[0:l] == "dns/" { - elem = elem[l:] - } else { - break - } + case 'r': // Prefix: "resolve" - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "auctions" - origElem := elem - if l := len("auctions"); len(elem) >= l && elem[0:l] == "auctions" { - elem = elem[l:] - } else { - break - } + if l := len("resolve"); len(elem) >= l && elem[0:l] == "resolve" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetAllAuctionsRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleDnsResolveRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - return - } + return + } - elem = origElem - } - // Param: "domain_name" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] + } - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetDnsInfoRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) } - return - } - switch elem[0] { - case '/': // Prefix: "/" + case 'e': // Prefix: "e" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + if l := len("e"); len(elem) >= l && elem[0:l] == "e" { elem = elem[l:] } else { break @@ -1725,25 +1874,64 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'b': // Prefix: "bids" + case 'v': // Prefix: "vents/" - if l := len("bids"); len(elem) >= l && elem[0:l] == "bids" { + if l := len("vents/"); len(elem) >= l && elem[0:l] == "vents/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. + break + } + switch elem[0] { + case 'e': // Prefix: "emulate" + origElem := elem + if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleEmulateMessageToEventRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn22AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } + + return + } + + elem = origElem + } + // Param: "event_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { switch r.Method { case "GET": - s.handleGetDomainBidsRequest([1]string{ + s.handleGetEventRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", - allowedHeaders: nil, + allowedHeaders: rn93AllowedHeaders, acceptPost: "", acceptPatch: "", }) @@ -1751,20 +1939,58 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } + switch elem[0] { + case '/': // Prefix: "/jettons" + + if l := len("/jettons"); len(elem) >= l && elem[0:l] == "/jettons" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetJettonsEventsRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: rn112AllowedHeaders, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } - case 'r': // Prefix: "resolve" + case 'x': // Prefix: "xtra-currency/" - if l := len("resolve"); len(elem) >= l && elem[0:l] == "resolve" { + if l := len("xtra-currency/"); len(elem) >= l && elem[0:l] == "xtra-currency/" { elem = elem[l:] } else { break } + // Param: "id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + if len(elem) == 0 { // Leaf node. switch r.Method { case "GET": - s.handleDnsResolveRequest([1]string{ + s.handleGetExtraCurrencyInfoRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: @@ -1781,23 +2007,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } - } - - case 'e': // Prefix: "e" - - if l := len("e"); len(elem) >= l && elem[0:l] == "e" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'v': // Prefix: "vents/" + case 'g': // Prefix: "gasless/" - if l := len("vents/"); len(elem) >= l && elem[0:l] == "vents/" { + if l := len("gasless/"); len(elem) >= l && elem[0:l] == "gasless/" { elem = elem[l:] } else { break @@ -1807,9 +2019,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'e': // Prefix: "emulate" - origElem := elem - if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { + case 'c': // Prefix: "config" + + if l := len("config"); len(elem) >= l && elem[0:l] == "config" { elem = elem[l:] } else { break @@ -1818,13 +2030,13 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { // Leaf node. switch r.Method { - case "POST": - s.handleEmulateMessageToEventRequest([0]string{}, elemIsEscaped, w, r) + case "GET": + s.handleGaslessConfigRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn22AllowedHeaders, - acceptPost: "application/json", + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", acceptPatch: "", }) } @@ -1832,55 +2044,35 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - elem = origElem - } - // Param: "event_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] - - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetEventRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: rn91AllowedHeaders, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - switch elem[0] { - case '/': // Prefix: "/jettons" + case 'e': // Prefix: "estimate/" - if l := len("/jettons"); len(elem) >= l && elem[0:l] == "/jettons" { + if l := len("estimate/"); len(elem) >= l && elem[0:l] == "estimate/" { elem = elem[l:] } else { break } + // Param: "master_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + if len(elem) == 0 { // Leaf node. switch r.Method { - case "GET": - s.handleGetJettonsEventsRequest([1]string{ + case "POST": + s.handleGaslessEstimateRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: rn110AllowedHeaders, - acceptPost: "", + allowedMethods: "POST", + allowedHeaders: rn31AllowedHeaders, + acceptPost: "application/json", acceptPatch: "", }) } @@ -1888,199 +2080,23 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - } - - case 'x': // Prefix: "xtra-currency/" + case 's': // Prefix: "send" - if l := len("xtra-currency/"); len(elem) >= l && elem[0:l] == "xtra-currency/" { - elem = elem[l:] - } else { - break - } - - // Param: "id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetExtraCurrencyInfoRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - } - - case 'g': // Prefix: "gasless/" - - if l := len("gasless/"); len(elem) >= l && elem[0:l] == "gasless/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'c': // Prefix: "config" - - if l := len("config"); len(elem) >= l && elem[0:l] == "config" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGaslessConfigRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - case 'e': // Prefix: "estimate/" - - if l := len("estimate/"); len(elem) >= l && elem[0:l] == "estimate/" { - elem = elem[l:] - } else { - break - } - - // Param: "master_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleGaslessEstimateRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn31AllowedHeaders, - acceptPost: "application/json", - acceptPatch: "", - }) - } - - return - } - - case 's': // Prefix: "send" - - if l := len("send"); len(elem) >= l && elem[0:l] == "send" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleGaslessSendRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn32AllowedHeaders, - acceptPost: "application/json", - acceptPatch: "", - }) - } - - return - } - - } - - case 'j': // Prefix: "jettons" - - if l := len("jettons"); len(elem) >= l && elem[0:l] == "jettons" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetJettonsRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - switch elem[0] { - case '/': // Prefix: "/" - - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case '_': // Prefix: "_bulk" - origElem := elem - if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { - elem = elem[l:] - } else { - break - } + if l := len("send"); len(elem) >= l && elem[0:l] == "send" { + elem = elem[l:] + } else { + break + } if len(elem) == 0 { // Leaf node. switch r.Method { case "POST": - s.handleGetJettonInfosByAddressesRequest([0]string{}, elemIsEscaped, w, r) + s.handleGaslessSendRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "POST", - allowedHeaders: rn105AllowedHeaders, + allowedHeaders: rn32AllowedHeaders, acceptPost: "application/json", acceptPatch: "", }) @@ -2089,23 +2105,20 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - elem = origElem } - // Param: "jetton_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) + + case 'j': // Prefix: "jettons" + + if l := len("jettons"); len(elem) >= l && elem[0:l] == "jettons" { + elem = elem[l:] + } else { + break } - args[0] = elem[:idx] - elem = elem[idx:] if len(elem) == 0 { switch r.Method { case "GET": - s.handleGetJettonInfoRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) + s.handleGetJettonsRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -2130,30 +2143,126 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'a': // Prefix: "accounts/" - - if l := len("accounts/"); len(elem) >= l && elem[0:l] == "accounts/" { + case '_': // Prefix: "_bulk" + origElem := elem + if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { elem = elem[l:] } else { break } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleGetJettonInfosByAddressesRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn107AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } + + return + } + + elem = origElem + } + // Param: "jetton_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + switch r.Method { + case "GET": + s.handleGetJettonInfoRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + switch elem[0] { + case '/': // Prefix: "/" + + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break } - args[1] = elem[:idx] - elem = elem[idx:] if len(elem) == 0 { break } switch elem[0] { - case '/': // Prefix: "/history" + case 'a': // Prefix: "accounts/" + + if l := len("accounts/"); len(elem) >= l && elem[0:l] == "accounts/" { + elem = elem[l:] + } else { + break + } + + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[1] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + break + } + switch elem[0] { + case '/': // Prefix: "/history" - if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetJettonAccountHistoryByIDRequest([2]string{ + args[0], + args[1], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } + + case 'h': // Prefix: "holders" + + if l := len("holders"); len(elem) >= l && elem[0:l] == "holders" { elem = elem[l:] } else { break @@ -2163,9 +2272,8 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetJettonAccountHistoryByIDRequest([2]string{ + s.handleGetJettonHoldersRequest([1]string{ args[0], - args[1], }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ @@ -2179,82 +2287,55 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - } - - case 'h': // Prefix: "holders" + case 't': // Prefix: "transfer/" - if l := len("holders"); len(elem) >= l && elem[0:l] == "holders" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetJettonHoldersRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - case 't': // Prefix: "transfer/" - - if l := len("transfer/"); len(elem) >= l && elem[0:l] == "transfer/" { - elem = elem[l:] - } else { - break - } - - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[1] = elem[:idx] - elem = elem[idx:] - - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/payload" - - if l := len("/payload"); len(elem) >= l && elem[0:l] == "/payload" { + if l := len("transfer/"); len(elem) >= l && elem[0:l] == "transfer/" { elem = elem[l:] } else { break } + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[1] = elem[:idx] + elem = elem[idx:] + if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetJettonTransferPayloadRequest([2]string{ - args[0], - args[1], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + break + } + switch elem[0] { + case '/': // Prefix: "/payload" + + if l := len("/payload"); len(elem) >= l && elem[0:l] == "/payload" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetJettonTransferPayloadRequest([2]string{ + args[0], + args[1], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return } - return } } @@ -2263,23 +2344,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } - } - - case 'l': // Prefix: "liteserver/" - - if l := len("liteserver/"); len(elem) >= l && elem[0:l] == "liteserver/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'g': // Prefix: "get_" + case 'l': // Prefix: "liteserver/" - if l := len("get_"); len(elem) >= l && elem[0:l] == "get_" { + if l := len("liteserver/"); len(elem) >= l && elem[0:l] == "liteserver/" { elem = elem[l:] } else { break @@ -2289,9 +2356,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'a': // Prefix: "a" + case 'g': // Prefix: "get_" - if l := len("a"); len(elem) >= l && elem[0:l] == "a" { + if l := len("get_"); len(elem) >= l && elem[0:l] == "get_" { elem = elem[l:] } else { break @@ -2301,131 +2368,95 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'c': // Prefix: "ccount_state/" + case 'a': // Prefix: "a" - if l := len("ccount_state/"); len(elem) >= l && elem[0:l] == "ccount_state/" { + if l := len("a"); len(elem) >= l && elem[0:l] == "a" { elem = elem[l:] } else { break } - // Param: "account_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetRawAccountStateRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - case 'l': // Prefix: "ll_shards_info/" - - if l := len("ll_shards_info/"); len(elem) >= l && elem[0:l] == "ll_shards_info/" { - elem = elem[l:] - } else { - break - } - - // Param: "block_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { break } - args[0] = elem - elem = "" + switch elem[0] { + case 'c': // Prefix: "ccount_state/" - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetAllRawShardsInfoRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + if l := len("ccount_state/"); len(elem) >= l && elem[0:l] == "ccount_state/" { + elem = elem[l:] + } else { + break } - return - } + // Param: "account_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetRawAccountStateRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - case 'b': // Prefix: "block" + return + } - if l := len("block"); len(elem) >= l && elem[0:l] == "block" { - elem = elem[l:] - } else { - break - } + case 'l': // Prefix: "ll_shards_info/" - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/" + if l := len("ll_shards_info/"); len(elem) >= l && elem[0:l] == "ll_shards_info/" { + elem = elem[l:] + } else { + break + } - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { - elem = elem[l:] - } else { - break - } + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" - // Param: "block_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetAllRawShardsInfoRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetRawBlockchainBlockRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + return } - return } - case '_': // Prefix: "_" + case 'b': // Prefix: "block" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + if l := len("block"); len(elem) >= l && elem[0:l] == "block" { elem = elem[l:] } else { break @@ -2435,9 +2466,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'h': // Prefix: "header/" + case '/': // Prefix: "/" - if l := len("header/"); len(elem) >= l && elem[0:l] == "header/" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break @@ -2456,7 +2487,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetRawBlockchainBlockHeaderRequest([1]string{ + s.handleGetRawBlockchainBlockRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: @@ -2471,108 +2502,107 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - case 'p': // Prefix: "proof" + case '_': // Prefix: "_" - if l := len("proof"); len(elem) >= l && elem[0:l] == "proof" { + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetRawBlockProofRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return + break } + switch elem[0] { + case 'h': // Prefix: "header/" - } + if l := len("header/"); len(elem) >= l && elem[0:l] == "header/" { + elem = elem[l:] + } else { + break + } - } + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" - case 'c': // Prefix: "config_all/" + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetRawBlockchainBlockHeaderRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - if l := len("config_all/"); len(elem) >= l && elem[0:l] == "config_all/" { - elem = elem[l:] - } else { - break - } + return + } - // Param: "block_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" + case 'p': // Prefix: "proof" - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetRawConfigRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } + if l := len("proof"); len(elem) >= l && elem[0:l] == "proof" { + elem = elem[l:] + } else { + break + } - return - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetRawBlockProofRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - case 'm': // Prefix: "masterchain_info" + return + } - if l := len("masterchain_info"); len(elem) >= l && elem[0:l] == "masterchain_info" { - elem = elem[l:] - } else { - break - } + } - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetRawMasterchainInfoRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) } - return - } - switch elem[0] { - case '_': // Prefix: "_ext" + case 'c': // Prefix: "config_all/" - if l := len("_ext"); len(elem) >= l && elem[0:l] == "_ext" { + if l := len("config_all/"); len(elem) >= l && elem[0:l] == "config_all/" { elem = elem[l:] } else { break } + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + if len(elem) == 0 { // Leaf node. switch r.Method { case "GET": - s.handleGetRawMasterchainInfoExtRequest([0]string{}, elemIsEscaped, w, r) + s.handleGetRawConfigRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -2585,117 +2615,43 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - } - - case 'o': // Prefix: "out_msg_queue_sizes" - - if l := len("out_msg_queue_sizes"); len(elem) >= l && elem[0:l] == "out_msg_queue_sizes" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetOutMsgQueueSizesRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - case 's': // Prefix: "s" - - if l := len("s"); len(elem) >= l && elem[0:l] == "s" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'h': // Prefix: "hard_" + case 'm': // Prefix: "masterchain_info" - if l := len("hard_"); len(elem) >= l && elem[0:l] == "hard_" { + if l := len("masterchain_info"); len(elem) >= l && elem[0:l] == "masterchain_info" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'b': // Prefix: "block_proof/" - - if l := len("block_proof/"); len(elem) >= l && elem[0:l] == "block_proof/" { - elem = elem[l:] - } else { - break - } - - // Param: "block_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetRawShardBlockProofRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return + switch r.Method { + case "GET": + s.handleGetRawMasterchainInfoRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) } - case 'i': // Prefix: "info/" + return + } + switch elem[0] { + case '_': // Prefix: "_ext" - if l := len("info/"); len(elem) >= l && elem[0:l] == "info/" { + if l := len("_ext"); len(elem) >= l && elem[0:l] == "_ext" { elem = elem[l:] } else { break } - // Param: "block_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - if len(elem) == 0 { // Leaf node. switch r.Method { case "GET": - s.handleGetRawShardInfoRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) + s.handleGetRawMasterchainInfoExtRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -2710,30 +2666,19 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } - case 't': // Prefix: "tate/" + case 'o': // Prefix: "out_msg_queue_sizes" - if l := len("tate/"); len(elem) >= l && elem[0:l] == "tate/" { + if l := len("out_msg_queue_sizes"); len(elem) >= l && elem[0:l] == "out_msg_queue_sizes" { elem = elem[l:] } else { break } - // Param: "block_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - if len(elem) == 0 { // Leaf node. switch r.Method { case "GET": - s.handleGetRawBlockchainBlockStateRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) + s.handleGetOutMsgQueueSizesRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -2746,205 +2691,369 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - } - - case 't': // Prefix: "t" - - if l := len("t"); len(elem) >= l && elem[0:l] == "t" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'i': // Prefix: "ime" + case 's': // Prefix: "s" - if l := len("ime"); len(elem) >= l && elem[0:l] == "ime" { + if l := len("s"); len(elem) >= l && elem[0:l] == "s" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetRawTimeRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return + break } + switch elem[0] { + case 'h': // Prefix: "hard_" - case 'r': // Prefix: "ransactions/" + if l := len("hard_"); len(elem) >= l && elem[0:l] == "hard_" { + elem = elem[l:] + } else { + break + } - if l := len("ransactions/"); len(elem) >= l && elem[0:l] == "ransactions/" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'b': // Prefix: "block_proof/" - // Param: "account_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { + if l := len("block_proof/"); len(elem) >= l && elem[0:l] == "block_proof/" { + elem = elem[l:] + } else { + break + } + + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetRawShardBlockProofRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + case 'i': // Prefix: "info/" + + if l := len("info/"); len(elem) >= l && elem[0:l] == "info/" { + elem = elem[l:] + } else { + break + } + + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetRawShardInfoRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } + + case 't': // Prefix: "tate/" + + if l := len("tate/"); len(elem) >= l && elem[0:l] == "tate/" { + elem = elem[l:] + } else { + break + } + + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetRawBlockchainBlockStateRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } + + case 't': // Prefix: "t" + + if l := len("t"); len(elem) >= l && elem[0:l] == "t" { + elem = elem[l:] + } else { break } - args[0] = elem - elem = "" if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetRawTransactionsRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + break + } + switch elem[0] { + case 'i': // Prefix: "ime" + + if l := len("ime"); len(elem) >= l && elem[0:l] == "ime" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetRawTimeRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + case 'r': // Prefix: "ransactions/" + + if l := len("ransactions/"); len(elem) >= l && elem[0:l] == "ransactions/" { + elem = elem[l:] + } else { + break + } + + // Param: "account_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetRawTransactionsRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return } - return } } - } + case 'l': // Prefix: "list_block_transactions/" - case 'l': // Prefix: "list_block_transactions/" + if l := len("list_block_transactions/"); len(elem) >= l && elem[0:l] == "list_block_transactions/" { + elem = elem[l:] + } else { + break + } - if l := len("list_block_transactions/"); len(elem) >= l && elem[0:l] == "list_block_transactions/" { - elem = elem[l:] - } else { - break - } + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" - // Param: "block_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetRawListBlockTransactionsRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetRawListBlockTransactionsRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + return + } + + case 's': // Prefix: "send_message" + + if l := len("send_message"); len(elem) >= l && elem[0:l] == "send_message" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleSendRawMessageRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn196AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } + + return } - return } - case 's': // Prefix: "send_message" + case 'm': // Prefix: "m" - if l := len("send_message"); len(elem) >= l && elem[0:l] == "send_message" { + if l := len("m"); len(elem) >= l && elem[0:l] == "m" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleSendRawMessageRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn192AllowedHeaders, - acceptPost: "application/json", - acceptPatch: "", - }) - } - - return + break } + switch elem[0] { + case 'e': // Prefix: "essage/decode" - } + if l := len("essage/decode"); len(elem) >= l && elem[0:l] == "essage/decode" { + elem = elem[l:] + } else { + break + } - case 'm': // Prefix: "m" + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleDecodeMessageRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn12AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } - if l := len("m"); len(elem) >= l && elem[0:l] == "m" { - elem = elem[l:] - } else { - break - } + return + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'e': // Prefix: "essage/decode" + case 'u': // Prefix: "ultisig/" - if l := len("essage/decode"); len(elem) >= l && elem[0:l] == "essage/decode" { - elem = elem[l:] - } else { - break - } + if l := len("ultisig/"); len(elem) >= l && elem[0:l] == "ultisig/" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleDecodeMessageRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn12AllowedHeaders, - acceptPost: "application/json", - acceptPatch: "", - }) + if len(elem) == 0 { + break } + switch elem[0] { + case 'o': // Prefix: "order/" + origElem := elem + if l := len("order/"); len(elem) >= l && elem[0:l] == "order/" { + elem = elem[l:] + } else { + break + } - return - } + // Param: "account_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" - case 'u': // Prefix: "ultisig/" + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetMultisigOrderRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - if l := len("ultisig/"); len(elem) >= l && elem[0:l] == "ultisig/" { - elem = elem[l:] - } else { - break - } + return + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'o': // Prefix: "order/" - origElem := elem - if l := len("order/"); len(elem) >= l && elem[0:l] == "order/" { - elem = elem[l:] - } else { - break + elem = origElem } - // Param: "account_id" // Leaf parameter, slashes are prohibited idx := strings.IndexByte(elem, '/') @@ -2958,7 +3067,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetMultisigOrderRequest([1]string{ + s.handleGetMultisigAccountRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: @@ -2973,154 +3082,58 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - elem = origElem - } - // Param: "account_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetMultisigAccountRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return } - } - - case 'n': // Prefix: "nfts/" + case 'n': // Prefix: "nfts/" - if l := len("nfts/"); len(elem) >= l && elem[0:l] == "nfts/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case '_': // Prefix: "_bulk" - origElem := elem - if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { + if l := len("nfts/"); len(elem) >= l && elem[0:l] == "nfts/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleGetNftItemsByAddressesRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn125AllowedHeaders, - acceptPost: "application/json", - acceptPatch: "", - }) - } - - return - } - - elem = origElem - case 'c': // Prefix: "collections" - origElem := elem - if l := len("collections"); len(elem) >= l && elem[0:l] == "collections" { - elem = elem[l:] - } else { break } - - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetNftCollectionsRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } switch elem[0] { - case '/': // Prefix: "/" - - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + case '_': // Prefix: "_bulk" + origElem := elem + if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case '_': // Prefix: "_bulk" - origElem := elem - if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleGetNftCollectionItemsByAddressesRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn120AllowedHeaders, - acceptPost: "application/json", - acceptPatch: "", - }) - } - - return + // Leaf node. + switch r.Method { + case "POST": + s.handleGetNftItemsByAddressesRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn127AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) } - elem = origElem + return } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) + + elem = origElem + case 'c': // Prefix: "collections" + origElem := elem + if l := len("collections"); len(elem) >= l && elem[0:l] == "collections" { + elem = elem[l:] + } else { + break } - args[0] = elem[:idx] - elem = elem[idx:] if len(elem) == 0 { switch r.Method { case "GET": - s.handleGetNftCollectionRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) + s.handleGetNftCollectionsRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -3133,19 +3146,58 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } switch elem[0] { - case '/': // Prefix: "/items" + case '/': // Prefix: "/" - if l := len("/items"); len(elem) >= l && elem[0:l] == "/items" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. + break + } + switch elem[0] { + case '_': // Prefix: "_bulk" + origElem := elem + if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleGetNftCollectionItemsByAddressesRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn122AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } + + return + } + + elem = origElem + } + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { switch r.Method { case "GET": - s.handleGetItemsFromCollectionRequest([1]string{ + s.handleGetNftCollectionRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: @@ -3159,119 +3211,55 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } + switch elem[0] { + case '/': // Prefix: "/items" - } - - } - - elem = origElem - } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] - - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetNftItemByAddressRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - switch elem[0] { - case '/': // Prefix: "/history" - - if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetNftHistoryByIDRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: rn124AllowedHeaders, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - } - - case 'o': // Prefix: "openapi." + if l := len("/items"); len(elem) >= l && elem[0:l] == "/items" { + elem = elem[l:] + } else { + break + } - if l := len("openapi."); len(elem) >= l && elem[0:l] == "openapi." { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetItemsFromCollectionRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'j': // Prefix: "json" + return + } - if l := len("json"); len(elem) >= l && elem[0:l] == "json" { - elem = elem[l:] - } else { - break - } + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetOpenapiJsonRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) } - return + elem = origElem } - - case 'y': // Prefix: "yml" - - if l := len("yml"); len(elem) >= l && elem[0:l] == "yml" { - elem = elem[l:] - } else { - break + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) } + args[0] = elem[:idx] + elem = elem[idx:] if len(elem) == 0 { - // Leaf node. switch r.Method { case "GET": - s.handleGetOpenapiYmlRequest([0]string{}, elemIsEscaped, w, r) + s.handleGetNftItemByAddressRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -3283,36 +3271,10 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - - } - - case 'p': // Prefix: "pu" - - if l := len("pu"); len(elem) >= l && elem[0:l] == "pu" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'b': // Prefix: "bkeys/" - - if l := len("bkeys/"); len(elem) >= l && elem[0:l] == "bkeys/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } switch elem[0] { - case 'w': // Prefix: "wallets/_bulk" - origElem := elem - if l := len("wallets/_bulk"); len(elem) >= l && elem[0:l] == "wallets/_bulk" { + case '/': // Prefix: "/history" + + if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { elem = elem[l:] } else { break @@ -3321,13 +3283,15 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { if len(elem) == 0 { // Leaf node. switch r.Method { - case "POST": - s.handleGetWalletsByPublicKeyBulkRequest([0]string{}, elemIsEscaped, w, r) + case "GET": + s.handleGetNftHistoryByIDRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn188AllowedHeaders, - acceptPost: "application/json", + allowedMethods: "GET", + allowedHeaders: rn126AllowedHeaders, + acceptPost: "", acceptPatch: "", }) } @@ -3335,24 +3299,23 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - elem = origElem } - // Param: "public_key" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) + + case 'o': // Prefix: "openapi." + + if l := len("openapi."); len(elem) >= l && elem[0:l] == "openapi." { + elem = elem[l:] + } else { + break } - args[0] = elem[:idx] - elem = elem[idx:] if len(elem) == 0 { break } switch elem[0] { - case '/': // Prefix: "/wallets" + case 'j': // Prefix: "json" - if l := len("/wallets"); len(elem) >= l && elem[0:l] == "/wallets" { + if l := len("json"); len(elem) >= l && elem[0:l] == "json" { elem = elem[l:] } else { break @@ -3362,9 +3325,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetWalletsByPublicKeyRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) + s.handleGetOpenapiJsonRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -3377,32 +3338,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } - } - - case 'r': // Prefix: "rchases/" - - if l := len("rchases/"); len(elem) >= l && elem[0:l] == "rchases/" { - elem = elem[l:] - } else { - break - } - - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] - - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/history" + case 'y': // Prefix: "yml" - if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + if l := len("yml"); len(elem) >= l && elem[0:l] == "yml" { elem = elem[l:] } else { break @@ -3412,9 +3350,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetPurchaseHistoryRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) + s.handleGetOpenapiYmlRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -3429,35 +3365,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } - } - - case 'r': // Prefix: "rates" - - if l := len("rates"); len(elem) >= l && elem[0:l] == "rates" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetRatesRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - switch elem[0] { - case '/': // Prefix: "/" + case 'p': // Prefix: "pu" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + if l := len("pu"); len(elem) >= l && elem[0:l] == "pu" { elem = elem[l:] } else { break @@ -3467,87 +3377,166 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'c': // Prefix: "chart" + case 'b': // Prefix: "bkeys/" - if l := len("chart"); len(elem) >= l && elem[0:l] == "chart" { + if l := len("bkeys/"); len(elem) >= l && elem[0:l] == "bkeys/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetChartRatesRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + break + } + switch elem[0] { + case 'w': // Prefix: "wallets/_bulk" + origElem := elem + if l := len("wallets/_bulk"); len(elem) >= l && elem[0:l] == "wallets/_bulk" { + elem = elem[l:] + } else { + break } - return + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleGetWalletsByPublicKeyBulkRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn190AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } + + return + } + + elem = origElem + } + // Param: "public_key" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + break } + switch elem[0] { + case '/': // Prefix: "/wallets" + + if l := len("/wallets"); len(elem) >= l && elem[0:l] == "/wallets" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetWalletsByPublicKeyRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } - case 'm': // Prefix: "markets" + } + + case 'r': // Prefix: "rchases/" - if l := len("markets"); len(elem) >= l && elem[0:l] == "markets" { + if l := len("rchases/"); len(elem) >= l && elem[0:l] == "rchases/" { elem = elem[l:] } else { break } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetMarketsRatesRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] - return + if len(elem) == 0 { + break } + switch elem[0] { + case '/': // Prefix: "/history" - } + if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + elem = elem[l:] + } else { + break + } - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetPurchaseHistoryRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - case 's': // Prefix: "st" + return + } - if l := len("st"); len(elem) >= l && elem[0:l] == "st" { - elem = elem[l:] - } else { - break - } + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "a" + } - if l := len("a"); len(elem) >= l && elem[0:l] == "a" { + case 'r': // Prefix: "rates" + + if l := len("rates"); len(elem) >= l && elem[0:l] == "rates" { elem = elem[l:] } else { break } - if len(elem) == 0 { - break + if len(elem) == 0 { + switch r.Method { + case "GET": + s.handleGetRatesRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return } switch elem[0] { - case 'k': // Prefix: "king/" + case '/': // Prefix: "/" - if l := len("king/"); len(elem) >= l && elem[0:l] == "king/" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break @@ -3557,59 +3546,87 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'n': // Prefix: "nominator/" + case 'c': // Prefix: "chart" - if l := len("nominator/"); len(elem) >= l && elem[0:l] == "nominator/" { + if l := len("chart"); len(elem) >= l && elem[0:l] == "chart" { elem = elem[l:] } else { break } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetChartRatesRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return } - args[0] = elem[:idx] - elem = elem[idx:] - if len(elem) == 0 { + case 'm': // Prefix: "markets" + + if l := len("markets"); len(elem) >= l && elem[0:l] == "markets" { + elem = elem[l:] + } else { break } - switch elem[0] { - case '/': // Prefix: "/pools" - if l := len("/pools"); len(elem) >= l && elem[0:l] == "/pools" { - elem = elem[l:] - } else { - break + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetMarketsRatesRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetAccountNominatorsPoolsRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } + return + } - return - } + } - } + } + + case 's': // Prefix: "st" + + if l := len("st"); len(elem) >= l && elem[0:l] == "st" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "a" + + if l := len("a"); len(elem) >= l && elem[0:l] == "a" { + elem = elem[l:] + } else { + break + } - case 'p': // Prefix: "pool" + if len(elem) == 0 { + break + } + switch elem[0] { + case 'k': // Prefix: "king/" - if l := len("pool"); len(elem) >= l && elem[0:l] == "pool" { + if l := len("king/"); len(elem) >= l && elem[0:l] == "king/" { elem = elem[l:] } else { break @@ -3619,9 +3636,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case '/': // Prefix: "/" + case 'n': // Prefix: "nominator/" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + if l := len("nominator/"); len(elem) >= l && elem[0:l] == "nominator/" { elem = elem[l:] } else { break @@ -3637,26 +3654,12 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { elem = elem[idx:] if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetStakingPoolInfoRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: rn170AllowedHeaders, - acceptPost: "", - acceptPatch: "", - }) - } - - return + break } switch elem[0] { - case '/': // Prefix: "/history" + case '/': // Prefix: "/pools" - if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + if l := len("/pools"); len(elem) >= l && elem[0:l] == "/pools" { elem = elem[l:] } else { break @@ -3666,7 +3669,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetStakingPoolHistoryRequest([1]string{ + s.handleGetAccountNominatorsPoolsRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: @@ -3683,38 +3686,141 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } - case 's': // Prefix: "s" + case 'p': // Prefix: "pool" - if l := len("s"); len(elem) >= l && elem[0:l] == "s" { + if l := len("pool"); len(elem) >= l && elem[0:l] == "pool" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetStakingPoolsRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: rn173AllowedHeaders, - acceptPost: "", - acceptPatch: "", - }) + break + } + switch elem[0] { + case '/': // Prefix: "/" + + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } + + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + switch r.Method { + case "GET": + s.handleGetStakingPoolInfoRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: rn172AllowedHeaders, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + switch elem[0] { + case '/': // Prefix: "/history" + + if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetStakingPoolHistoryRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } + + case 's': // Prefix: "s" + + if l := len("s"); len(elem) >= l && elem[0:l] == "s" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetStakingPoolsRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: rn175AllowedHeaders, + acceptPost: "", + acceptPatch: "", + }) + } + + return } - return } } + case 't': // Prefix: "tus" + + if l := len("tus"); len(elem) >= l && elem[0:l] == "tus" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleStatusRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + } - case 't': // Prefix: "tus" + case 'o': // Prefix: "orage/providers" - if l := len("tus"); len(elem) >= l && elem[0:l] == "tus" { + if l := len("orage/providers"); len(elem) >= l && elem[0:l] == "orage/providers" { elem = elem[l:] } else { break @@ -3724,7 +3830,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleStatusRequest([0]string{}, elemIsEscaped, w, r) + s.handleGetStorageProvidersRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -3739,100 +3845,142 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } - case 'o': // Prefix: "orage/providers" + case 't': // Prefix: "t" - if l := len("orage/providers"); len(elem) >= l && elem[0:l] == "orage/providers" { + if l := len("t"); len(elem) >= l && elem[0:l] == "t" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetStorageProvidersRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + break + } + switch elem[0] { + case 'o': // Prefix: "onconnect/" + + if l := len("onconnect/"); len(elem) >= l && elem[0:l] == "onconnect/" { + elem = elem[l:] + } else { + break } - return - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'p': // Prefix: "payload" + + if l := len("payload"); len(elem) >= l && elem[0:l] == "payload" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetTonConnectPayloadRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } - } + case 's': // Prefix: "stateinit" - case 't': // Prefix: "t" + if l := len("stateinit"); len(elem) >= l && elem[0:l] == "stateinit" { + elem = elem[l:] + } else { + break + } - if l := len("t"); len(elem) >= l && elem[0:l] == "t" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleGetAccountInfoByStateInitRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn45AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'o': // Prefix: "onconnect/" + return + } - if l := len("onconnect/"); len(elem) >= l && elem[0:l] == "onconnect/" { - elem = elem[l:] - } else { - break - } + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'p': // Prefix: "payload" + case 'r': // Prefix: "races/" - if l := len("payload"); len(elem) >= l && elem[0:l] == "payload" { + if l := len("races/"); len(elem) >= l && elem[0:l] == "races/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetTonConnectPayloadRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + break + } + switch elem[0] { + case 'e': // Prefix: "emulate" + origElem := elem + if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { + elem = elem[l:] + } else { + break } - return - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleEmulateMessageToTraceRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn23AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } - case 's': // Prefix: "stateinit" + return + } - if l := len("stateinit"); len(elem) >= l && elem[0:l] == "stateinit" { - elem = elem[l:] - } else { + elem = origElem + } + // Param: "trace_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { break } + args[0] = elem + elem = "" if len(elem) == 0 { // Leaf node. switch r.Method { - case "POST": - s.handleGetAccountInfoByStateInitRequest([0]string{}, elemIsEscaped, w, r) + case "GET": + s.handleGetTraceRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn45AllowedHeaders, - acceptPost: "application/json", + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", acceptPatch: "", }) } @@ -3842,9 +3990,9 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } - case 'r': // Prefix: "races/" + case 'v': // Prefix: "validation/" - if l := len("races/"); len(elem) >= l && elem[0:l] == "races/" { + if l := len("validation/"); len(elem) >= l && elem[0:l] == "validation/" { elem = elem[l:] } else { break @@ -3854,115 +4002,73 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { break } switch elem[0] { - case 'e': // Prefix: "emulate" - origElem := elem - if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { + case 'r': // Prefix: "r" + + if l := len("r"); len(elem) >= l && elem[0:l] == "r" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleEmulateMessageToTraceRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn23AllowedHeaders, - acceptPost: "application/json", - acceptPatch: "", - }) - } - - return - } - - elem = origElem - } - // Param: "trace_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetTraceRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + break } + switch elem[0] { + case 'e': // Prefix: "ewards" - return - } - - } - - case 'v': // Prefix: "validation/" + if l := len("ewards"); len(elem) >= l && elem[0:l] == "ewards" { + elem = elem[l:] + } else { + break + } - if l := len("validation/"); len(elem) >= l && elem[0:l] == "validation/" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetRoundRewardsRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'r': // Prefix: "r" + return + } - if l := len("r"); len(elem) >= l && elem[0:l] == "r" { - elem = elem[l:] - } else { - break - } + case 'o': // Prefix: "ounds" - if len(elem) == 0 { - break - } - switch elem[0] { - case 'e': // Prefix: "ewards" + if l := len("ounds"); len(elem) >= l && elem[0:l] == "ounds" { + elem = elem[l:] + } else { + break + } - if l := len("ewards"); len(elem) >= l && elem[0:l] == "ewards" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetValidationRoundsRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetRoundRewardsRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + return } - return } - case 'o': // Prefix: "ounds" + case 'v': // Prefix: "validators" - if l := len("ounds"); len(elem) >= l && elem[0:l] == "ounds" { + if l := len("validators"); len(elem) >= l && elem[0:l] == "validators" { elem = elem[l:] } else { break @@ -3972,7 +4078,7 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { // Leaf node. switch r.Method { case "GET": - s.handleGetValidationRoundsRequest([0]string{}, elemIsEscaped, w, r) + s.handleGetValidatorsRequest([0]string{}, elemIsEscaped, w, r) default: s.notAllowed(w, r, notAllowedParams{ allowedMethods: "GET", @@ -3987,138 +4093,84 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { } - case 'v': // Prefix: "validators" + case 'w': // Prefix: "wallet/" - if l := len("validators"); len(elem) >= l && elem[0:l] == "validators" { + if l := len("wallet/"); len(elem) >= l && elem[0:l] == "wallet/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "GET": - s.handleGetValidatorsRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) - } - - return - } - - } - - case 'w': // Prefix: "wallet/" - - if l := len("wallet/"); len(elem) >= l && elem[0:l] == "wallet/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "auth/proof" - origElem := elem - if l := len("auth/proof"); len(elem) >= l && elem[0:l] == "auth/proof" { - elem = elem[l:] - } else { break } - - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleTonConnectProofRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn195AllowedHeaders, - acceptPost: "application/json", - acceptPatch: "", - }) + switch elem[0] { + case 'a': // Prefix: "auth/proof" + origElem := elem + if l := len("auth/proof"); len(elem) >= l && elem[0:l] == "auth/proof" { + elem = elem[l:] + } else { + break } - return - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleTonConnectProofRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn199AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } - elem = origElem - case 'e': // Prefix: "emulate" - origElem := elem - if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { - elem = elem[l:] - } else { - break - } + return + } - if len(elem) == 0 { - // Leaf node. - switch r.Method { - case "POST": - s.handleEmulateMessageToWalletRequest([0]string{}, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "POST", - allowedHeaders: rn24AllowedHeaders, - acceptPost: "application/json", - acceptPatch: "", - }) + elem = origElem + case 'e': // Prefix: "emulate" + origElem := elem + if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { + elem = elem[l:] + } else { + break } - return - } + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "POST": + s.handleEmulateMessageToWalletRequest([0]string{}, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "POST", + allowedHeaders: rn24AllowedHeaders, + acceptPost: "application/json", + acceptPatch: "", + }) + } - elem = origElem - } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] + return + } - if len(elem) == 0 { - switch r.Method { - case "GET": - s.handleGetWalletInfoRequest([1]string{ - args[0], - }, elemIsEscaped, w, r) - default: - s.notAllowed(w, r, notAllowedParams{ - allowedMethods: "GET", - allowedHeaders: nil, - acceptPost: "", - acceptPatch: "", - }) + elem = origElem } - - return - } - switch elem[0] { - case '/': // Prefix: "/seqno" - - if l := len("/seqno"); len(elem) >= l && elem[0:l] == "/seqno" { - elem = elem[l:] - } else { - break + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) } + args[0] = elem[:idx] + elem = elem[idx:] if len(elem) == 0 { - // Leaf node. switch r.Method { case "GET": - s.handleGetAccountSeqnoRequest([1]string{ + s.handleGetWalletInfoRequest([1]string{ args[0], }, elemIsEscaped, w, r) default: @@ -4132,6 +4184,35 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) { return } + switch elem[0] { + case '/': // Prefix: "/seqno" + + if l := len("/seqno"); len(elem) >= l && elem[0:l] == "/seqno" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch r.Method { + case "GET": + s.handleGetAccountSeqnoRequest([1]string{ + args[0], + }, elemIsEscaped, w, r) + default: + s.notAllowed(w, r, notAllowedParams{ + allowedMethods: "GET", + allowedHeaders: nil, + acceptPost: "", + acceptPatch: "", + }) + } + + return + } + + } } @@ -4223,9 +4304,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case '/': // Prefix: "/v2/" + case '/': // Prefix: "/" - if l := len("/v2/"); len(elem) >= l && elem[0:l] == "/v2/" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break @@ -4235,9 +4316,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'a': // Prefix: "a" + case 'c': // Prefix: "cocoon/" - if l := len("a"); len(elem) >= l && elem[0:l] == "a" { + if l := len("cocoon/"); len(elem) >= l && elem[0:l] == "cocoon/" { elem = elem[l:] } else { break @@ -4247,99 +4328,85 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'c': // Prefix: "ccounts/" + case 'q': // Prefix: "query" - if l := len("ccounts/"); len(elem) >= l && elem[0:l] == "ccounts/" { + if l := len("query"); len(elem) >= l && elem[0:l] == "query" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case '_': // Prefix: "_bulk" - origElem := elem - if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "POST": - r.name = GetAccountsOperation - r.summary = "" - r.operationID = "getAccounts" - r.operationGroup = "" - r.pathPattern = "/v2/accounts/_bulk" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - - elem = origElem - case 's': // Prefix: "search" - origElem := elem - if l := len("search"); len(elem) >= l && elem[0:l] == "search" { - elem = elem[l:] - } else { - break + // Leaf node. + switch method { + case "POST": + r.name = PostCocoonQueryOperation + r.summary = "" + r.operationID = "postCocoonQuery" + r.operationGroup = "" + r.pathPattern = "/cocoon/query" + r.args = args + r.count = 0 + return r, true + default: + return } + } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = SearchAccountsOperation - r.summary = "" - r.operationID = "searchAccounts" - r.operationGroup = "" - r.pathPattern = "/v2/accounts/search" - r.args = args - r.count = 0 - return r, true - default: - return - } - } + case 'w': // Prefix: "workers" - elem = origElem - } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) + if l := len("workers"); len(elem) >= l && elem[0:l] == "workers" { + elem = elem[l:] + } else { + break } - args[0] = elem[:idx] - elem = elem[idx:] if len(elem) == 0 { + // Leaf node. switch method { case "GET": - r.name = GetAccountOperation + r.name = GetCocoonWorkersOperation r.summary = "" - r.operationID = "getAccount" + r.operationID = "getCocoonWorkers" r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}" + r.pathPattern = "/cocoon/workers" r.args = args - r.count = 1 + r.count = 0 return r, true default: return } } + + } + + case 'v': // Prefix: "v2/" + + if l := len("v2/"); len(elem) >= l && elem[0:l] == "v2/" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "a" + + if l := len("a"); len(elem) >= l && elem[0:l] == "a" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } switch elem[0] { - case '/': // Prefix: "/" + case 'c': // Prefix: "ccounts/" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + if l := len("ccounts/"); len(elem) >= l && elem[0:l] == "ccounts/" { elem = elem[l:] } else { break @@ -4349,46 +4416,99 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'd': // Prefix: "d" - - if l := len("d"); len(elem) >= l && elem[0:l] == "d" { + case '_': // Prefix: "_bulk" + origElem := elem + if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = GetAccountsOperation + r.summary = "" + r.operationID = "getAccounts" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/_bulk" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + elem = origElem + case 's': // Prefix: "search" + origElem := elem + if l := len("search"); len(elem) >= l && elem[0:l] == "search" { + elem = elem[l:] + } else { break } - switch elem[0] { - case 'i': // Prefix: "iff" - if l := len("iff"); len(elem) >= l && elem[0:l] == "iff" { - elem = elem[l:] - } else { - break + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = SearchAccountsOperation + r.summary = "" + r.operationID = "searchAccounts" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/search" + r.args = args + r.count = 0 + return r, true + default: + return } + } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetAccountDiffOperation - r.summary = "" - r.operationID = "getAccountDiff" - r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/diff" - r.args = args - r.count = 1 - return r, true - default: - return - } - } + elem = origElem + } + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + switch method { + case "GET": + r.name = GetAccountOperation + r.summary = "" + r.operationID = "getAccount" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/{account_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/" + + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } - case 'n': // Prefix: "ns/" + if len(elem) == 0 { + break + } + switch elem[0] { + case 'd': // Prefix: "d" - if l := len("ns/"); len(elem) >= l && elem[0:l] == "ns/" { + if l := len("d"); len(elem) >= l && elem[0:l] == "d" { elem = elem[l:] } else { break @@ -4398,9 +4518,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'b': // Prefix: "backresolve" + case 'i': // Prefix: "iff" - if l := len("backresolve"); len(elem) >= l && elem[0:l] == "backresolve" { + if l := len("iff"); len(elem) >= l && elem[0:l] == "iff" { elem = elem[l:] } else { break @@ -4410,11 +4530,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = AccountDnsBackResolveOperation + r.name = GetAccountDiffOperation r.summary = "" - r.operationID = "accountDnsBackResolve" + r.operationID = "getAccountDiff" r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/dns/backresolve" + r.pathPattern = "/v2/accounts/{account_id}/diff" r.args = args r.count = 1 return r, true @@ -4423,23 +4543,100 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } - case 'e': // Prefix: "expiring" + case 'n': // Prefix: "ns/" - if l := len("expiring"); len(elem) >= l && elem[0:l] == "expiring" { + if l := len("ns/"); len(elem) >= l && elem[0:l] == "ns/" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'b': // Prefix: "backresolve" + + if l := len("backresolve"); len(elem) >= l && elem[0:l] == "backresolve" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = AccountDnsBackResolveOperation + r.summary = "" + r.operationID = "accountDnsBackResolve" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/{account_id}/dns/backresolve" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + case 'e': // Prefix: "expiring" + + if l := len("expiring"); len(elem) >= l && elem[0:l] == "expiring" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetAccountDnsExpiringOperation + r.summary = "" + r.operationID = "getAccountDnsExpiring" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/{account_id}/dns/expiring" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + } + + } + + case 'e': // Prefix: "e" + + if l := len("e"); len(elem) >= l && elem[0:l] == "e" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'v': // Prefix: "vents" + + if l := len("vents"); len(elem) >= l && elem[0:l] == "vents" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch method { case "GET": - r.name = GetAccountDnsExpiringOperation + r.name = GetAccountEventsOperation r.summary = "" - r.operationID = "getAccountDnsExpiring" + r.operationID = "getAccountEvents" r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/dns/expiring" + r.pathPattern = "/v2/accounts/{account_id}/events" r.args = args r.count = 1 return r, true @@ -4447,26 +4644,127 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { return } } + switch elem[0] { + case '/': // Prefix: "/" - } + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'e': // Prefix: "emulate" + origElem := elem + if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { + elem = elem[l:] + } else { + break + } - case 'e': // Prefix: "e" + if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = EmulateMessageToAccountEventOperation + r.summary = "" + r.operationID = "emulateMessageToAccountEvent" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/{account_id}/events/emulate" + r.args = args + r.count = 1 + return r, true + default: + return + } + } - if l := len("e"); len(elem) >= l && elem[0:l] == "e" { - elem = elem[l:] - } else { - break - } + elem = origElem + } + // Param: "event_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[1] = elem + elem = "" - if len(elem) == 0 { - break - } - switch elem[0] { - case 'v': // Prefix: "vents" + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetAccountEventOperation + r.summary = "" + r.operationID = "getAccountEvent" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/{account_id}/events/{event_id}" + r.args = args + r.count = 2 + return r, true + default: + return + } + } + + } + + case 'x': // Prefix: "xtra-currency/" + + if l := len("xtra-currency/"); len(elem) >= l && elem[0:l] == "xtra-currency/" { + elem = elem[l:] + } else { + break + } + + // Param: "id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[1] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + break + } + switch elem[0] { + case '/': // Prefix: "/history" + + if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + elem = elem[l:] + } else { + break + } - if l := len("vents"); len(elem) >= l && elem[0:l] == "vents" { + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetAccountExtraCurrencyHistoryByIDOperation + r.summary = "" + r.operationID = "getAccountExtraCurrencyHistoryByID" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/{account_id}/extra-currency/{id}/history" + r.args = args + r.count = 2 + return r, true + default: + return + } + } + + } + + } + + case 'j': // Prefix: "jettons" + + if l := len("jettons"); len(elem) >= l && elem[0:l] == "jettons" { elem = elem[l:] } else { break @@ -4475,11 +4773,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { if len(elem) == 0 { switch method { case "GET": - r.name = GetAccountEventsOperation + r.name = GetAccountJettonsBalancesOperation r.summary = "" - r.operationID = "getAccountEvents" + r.operationID = "getAccountJettonsBalances" r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/events" + r.pathPattern = "/v2/accounts/{account_id}/jettons" r.args = args r.count = 1 return r, true @@ -4500,9 +4798,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'e': // Prefix: "emulate" + case 'h': // Prefix: "history" origElem := elem - if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { + if l := len("history"); len(elem) >= l && elem[0:l] == "history" { elem = elem[l:] } else { break @@ -4511,12 +4809,12 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { if len(elem) == 0 { // Leaf node. switch method { - case "POST": - r.name = EmulateMessageToAccountEventOperation + case "GET": + r.name = GetAccountJettonsHistoryOperation r.summary = "" - r.operationID = "emulateMessageToAccountEvent" + r.operationID = "getAccountJettonsHistory" r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/events/emulate" + r.pathPattern = "/v2/accounts/{account_id}/jettons/history" r.args = args r.count = 1 return r, true @@ -4527,24 +4825,23 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { elem = origElem } - // Param: "event_id" - // Leaf parameter, slashes are prohibited + // Param: "jetton_id" + // Match until "/" idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break + if idx < 0 { + idx = len(elem) } - args[1] = elem - elem = "" + args[1] = elem[:idx] + elem = elem[idx:] if len(elem) == 0 { - // Leaf node. switch method { case "GET": - r.name = GetAccountEventOperation + r.name = GetAccountJettonBalanceOperation r.summary = "" - r.operationID = "getAccountEvent" + r.operationID = "getAccountJettonBalance" r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/events/{event_id}" + r.pathPattern = "/v2/accounts/{account_id}/jettons/{jetton_id}" r.args = args r.count = 2 return r, true @@ -4552,141 +4849,79 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { return } } + switch elem[0] { + case '/': // Prefix: "/history" - } - - case 'x': // Prefix: "xtra-currency/" - - if l := len("xtra-currency/"); len(elem) >= l && elem[0:l] == "xtra-currency/" { - elem = elem[l:] - } else { - break - } - - // Param: "id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[1] = elem[:idx] - elem = elem[idx:] - - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/history" - - if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { - elem = elem[l:] - } else { - break - } + if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetAccountExtraCurrencyHistoryByIDOperation - r.summary = "" - r.operationID = "getAccountExtraCurrencyHistoryByID" - r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/extra-currency/{id}/history" - r.args = args - r.count = 2 - return r, true - default: - return + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetAccountJettonHistoryByIDOperation + r.summary = "" + r.operationID = "getAccountJettonHistoryByID" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/{account_id}/jettons/{jetton_id}/history" + r.args = args + r.count = 2 + return r, true + default: + return + } } + } } - } - - case 'j': // Prefix: "jettons" - - if l := len("jettons"); len(elem) >= l && elem[0:l] == "jettons" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetAccountJettonsBalancesOperation - r.summary = "" - r.operationID = "getAccountJettonsBalances" - r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/jettons" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - switch elem[0] { - case '/': // Prefix: "/" + case 'm': // Prefix: "multisigs" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + if l := len("multisigs"); len(elem) >= l && elem[0:l] == "multisigs" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case 'h': // Prefix: "history" - origElem := elem - if l := len("history"); len(elem) >= l && elem[0:l] == "history" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetAccountJettonsHistoryOperation - r.summary = "" - r.operationID = "getAccountJettonsHistory" - r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/jettons/history" - r.args = args - r.count = 1 - return r, true - default: - return - } + // Leaf node. + switch method { + case "GET": + r.name = GetAccountMultisigsOperation + r.summary = "" + r.operationID = "getAccountMultisigs" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/{account_id}/multisigs" + r.args = args + r.count = 1 + return r, true + default: + return } - - elem = origElem } - // Param: "jetton_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) + + case 'n': // Prefix: "nfts" + + if l := len("nfts"); len(elem) >= l && elem[0:l] == "nfts" { + elem = elem[l:] + } else { + break } - args[1] = elem[:idx] - elem = elem[idx:] if len(elem) == 0 { switch method { case "GET": - r.name = GetAccountJettonBalanceOperation + r.name = GetAccountNftItemsOperation r.summary = "" - r.operationID = "getAccountJettonBalance" + r.operationID = "getAccountNftItems" r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/jettons/{jetton_id}" + r.pathPattern = "/v2/accounts/{account_id}/nfts" r.args = args - r.count = 2 + r.count = 1 return r, true default: return @@ -4705,13 +4940,13 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetAccountJettonHistoryByIDOperation + r.name = GetAccountNftHistoryOperation r.summary = "" - r.operationID = "getAccountJettonHistoryByID" + r.operationID = "getAccountNftHistory" r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/jettons/{jetton_id}/history" + r.pathPattern = "/v2/accounts/{account_id}/nfts/history" r.args = args - r.count = 2 + r.count = 1 return r, true default: return @@ -4720,60 +4955,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } - } - - case 'm': // Prefix: "multisigs" - - if l := len("multisigs"); len(elem) >= l && elem[0:l] == "multisigs" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetAccountMultisigsOperation - r.summary = "" - r.operationID = "getAccountMultisigs" - r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/multisigs" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - - case 'n': // Prefix: "nfts" - - if l := len("nfts"); len(elem) >= l && elem[0:l] == "nfts" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetAccountNftItemsOperation - r.summary = "" - r.operationID = "getAccountNftItems" - r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/nfts" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - switch elem[0] { - case '/': // Prefix: "/history" + case 'p': // Prefix: "publickey" - if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + if l := len("publickey"); len(elem) >= l && elem[0:l] == "publickey" { elem = elem[l:] } else { break @@ -4783,11 +4967,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetAccountNftHistoryOperation + r.name = GetAccountPublicKeyOperation r.summary = "" - r.operationID = "getAccountNftHistory" + r.operationID = "getAccountPublicKey" r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/nfts/history" + r.pathPattern = "/v2/accounts/{account_id}/publickey" r.args = args r.count = 1 return r, true @@ -4796,222 +4980,109 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } - } - - case 'p': // Prefix: "publickey" - - if l := len("publickey"); len(elem) >= l && elem[0:l] == "publickey" { - elem = elem[l:] - } else { - break - } + case 'r': // Prefix: "reindex" - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetAccountPublicKeyOperation - r.summary = "" - r.operationID = "getAccountPublicKey" - r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/publickey" - r.args = args - r.count = 1 - return r, true - default: - return + if l := len("reindex"); len(elem) >= l && elem[0:l] == "reindex" { + elem = elem[l:] + } else { + break } - } - - case 'r': // Prefix: "reindex" - - if l := len("reindex"); len(elem) >= l && elem[0:l] == "reindex" { - elem = elem[l:] - } else { - break - } - if len(elem) == 0 { - // Leaf node. - switch method { - case "POST": - r.name = ReindexAccountOperation - r.summary = "" - r.operationID = "reindexAccount" - r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/reindex" - r.args = args - r.count = 1 - return r, true - default: - return + if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = ReindexAccountOperation + r.summary = "" + r.operationID = "reindexAccount" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/{account_id}/reindex" + r.args = args + r.count = 1 + return r, true + default: + return + } } - } - case 's': // Prefix: "subscriptions" + case 's': // Prefix: "subscriptions" - if l := len("subscriptions"); len(elem) >= l && elem[0:l] == "subscriptions" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetAccountSubscriptionsOperation - r.summary = "" - r.operationID = "getAccountSubscriptions" - r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/subscriptions" - r.args = args - r.count = 1 - return r, true - default: - return + if l := len("subscriptions"); len(elem) >= l && elem[0:l] == "subscriptions" { + elem = elem[l:] + } else { + break } - } - - case 't': // Prefix: "traces" - - if l := len("traces"); len(elem) >= l && elem[0:l] == "traces" { - elem = elem[l:] - } else { - break - } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetAccountTracesOperation - r.summary = "" - r.operationID = "getAccountTraces" - r.operationGroup = "" - r.pathPattern = "/v2/accounts/{account_id}/traces" - r.args = args - r.count = 1 - return r, true - default: - return + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetAccountSubscriptionsOperation + r.summary = "" + r.operationID = "getAccountSubscriptions" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/{account_id}/subscriptions" + r.args = args + r.count = 1 + return r, true + default: + return + } } - } - - } - - } - - case 'd': // Prefix: "ddress/" - - if l := len("ddress/"); len(elem) >= l && elem[0:l] == "ddress/" { - elem = elem[l:] - } else { - break - } - - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] - - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/parse" - - if l := len("/parse"); len(elem) >= l && elem[0:l] == "/parse" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = AddressParseOperation - r.summary = "" - r.operationID = "addressParse" - r.operationGroup = "" - r.pathPattern = "/v2/address/{account_id}/parse" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - - } - - } - - case 'b': // Prefix: "blockchain/" - - if l := len("blockchain/"); len(elem) >= l && elem[0:l] == "blockchain/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "accounts/" - if l := len("accounts/"); len(elem) >= l && elem[0:l] == "accounts/" { - elem = elem[l:] - } else { - break - } + case 't': // Prefix: "traces" - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] + if l := len("traces"); len(elem) >= l && elem[0:l] == "traces" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetAccountTracesOperation + r.summary = "" + r.operationID = "getAccountTraces" + r.operationGroup = "" + r.pathPattern = "/v2/accounts/{account_id}/traces" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + } - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetBlockchainRawAccountOperation - r.summary = "" - r.operationID = "getBlockchainRawAccount" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/accounts/{account_id}" - r.args = args - r.count = 1 - return r, true - default: - return } - } - switch elem[0] { - case '/': // Prefix: "/" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + case 'd': // Prefix: "ddress/" + + if l := len("ddress/"); len(elem) >= l && elem[0:l] == "ddress/" { elem = elem[l:] } else { break } + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + if len(elem) == 0 { break } switch elem[0] { - case 'i': // Prefix: "inspect" + case '/': // Prefix: "/parse" - if l := len("inspect"); len(elem) >= l && elem[0:l] == "inspect" { + if l := len("/parse"); len(elem) >= l && elem[0:l] == "/parse" { elem = elem[l:] } else { break @@ -5021,11 +5092,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = BlockchainAccountInspectOperation + r.name = AddressParseOperation r.summary = "" - r.operationID = "blockchainAccountInspect" + r.operationID = "addressParse" r.operationGroup = "" - r.pathPattern = "/v2/blockchain/accounts/{account_id}/inspect" + r.pathPattern = "/v2/address/{account_id}/parse" r.args = args r.count = 1 return r, true @@ -5034,151 +5105,290 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } - case 'm': // Prefix: "methods/" + } + + } + + case 'b': // Prefix: "blockchain/" + + if l := len("blockchain/"); len(elem) >= l && elem[0:l] == "blockchain/" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "accounts/" + + if l := len("accounts/"); len(elem) >= l && elem[0:l] == "accounts/" { + elem = elem[l:] + } else { + break + } + + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + switch method { + case "GET": + r.name = GetBlockchainRawAccountOperation + r.summary = "" + r.operationID = "getBlockchainRawAccount" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/accounts/{account_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/" - if l := len("methods/"); len(elem) >= l && elem[0:l] == "methods/" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } - // Param: "method_name" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { + if len(elem) == 0 { break } - args[1] = elem - elem = "" + switch elem[0] { + case 'i': // Prefix: "inspect" - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = ExecGetMethodForBlockchainAccountOperation - r.summary = "" - r.operationID = "execGetMethodForBlockchainAccount" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/accounts/{account_id}/methods/{method_name}" - r.args = args - r.count = 2 - return r, true - case "POST": - r.name = ExecGetMethodWithBodyForBlockchainAccountOperation - r.summary = "" - r.operationID = "execGetMethodWithBodyForBlockchainAccount" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/accounts/{account_id}/methods/{method_name}" - r.args = args - r.count = 2 - return r, true - default: - return + if l := len("inspect"); len(elem) >= l && elem[0:l] == "inspect" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = BlockchainAccountInspectOperation + r.summary = "" + r.operationID = "blockchainAccountInspect" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/accounts/{account_id}/inspect" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + case 'm': // Prefix: "methods/" + + if l := len("methods/"); len(elem) >= l && elem[0:l] == "methods/" { + elem = elem[l:] + } else { + break + } + + // Param: "method_name" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[1] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = ExecGetMethodForBlockchainAccountOperation + r.summary = "" + r.operationID = "execGetMethodForBlockchainAccount" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/accounts/{account_id}/methods/{method_name}" + r.args = args + r.count = 2 + return r, true + case "POST": + r.name = ExecGetMethodWithBodyForBlockchainAccountOperation + r.summary = "" + r.operationID = "execGetMethodWithBodyForBlockchainAccount" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/accounts/{account_id}/methods/{method_name}" + r.args = args + r.count = 2 + return r, true + default: + return + } + } + + case 't': // Prefix: "transactions" + + if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetBlockchainAccountTransactionsOperation + r.summary = "" + r.operationID = "getBlockchainAccountTransactions" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/accounts/{account_id}/transactions" + r.args = args + r.count = 1 + return r, true + default: + return + } } + } - case 't': // Prefix: "transactions" + } + + case 'b': // Prefix: "blocks/" + + if l := len("blocks/"); len(elem) >= l && elem[0:l] == "blocks/" { + elem = elem[l:] + } else { + break + } + + // Param: "block_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + switch method { + case "GET": + r.name = GetBlockchainBlockOperation + r.summary = "" + r.operationID = "getBlockchainBlock" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/blocks/{block_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/" - if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetBlockchainAccountTransactionsOperation - r.summary = "" - r.operationID = "getBlockchainAccountTransactions" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/accounts/{account_id}/transactions" - r.args = args - r.count = 1 - return r, true - default: - return - } + break } + switch elem[0] { + case 'b': // Prefix: "boc" - } - - } + if l := len("boc"); len(elem) >= l && elem[0:l] == "boc" { + elem = elem[l:] + } else { + break + } - case 'b': // Prefix: "blocks/" + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = DownloadBlockchainBlockBocOperation + r.summary = "" + r.operationID = "downloadBlockchainBlockBoc" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/blocks/{block_id}/boc" + r.args = args + r.count = 1 + return r, true + default: + return + } + } - if l := len("blocks/"); len(elem) >= l && elem[0:l] == "blocks/" { - elem = elem[l:] - } else { - break - } + case 't': // Prefix: "transactions" - // Param: "block_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] + if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetBlockchainBlockTransactionsOperation + r.summary = "" + r.operationID = "getBlockchainBlockTransactions" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/blocks/{block_id}/transactions" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + } - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetBlockchainBlockOperation - r.summary = "" - r.operationID = "getBlockchainBlock" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/blocks/{block_id}" - r.args = args - r.count = 1 - return r, true - default: - return } - } - switch elem[0] { - case '/': // Prefix: "/" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + case 'c': // Prefix: "config" + + if l := len("config"); len(elem) >= l && elem[0:l] == "config" { elem = elem[l:] } else { break } if len(elem) == 0 { - break + switch method { + case "GET": + r.name = GetBlockchainConfigOperation + r.summary = "" + r.operationID = "getBlockchainConfig" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/config" + r.args = args + r.count = 0 + return r, true + default: + return + } } switch elem[0] { - case 'b': // Prefix: "boc" - - if l := len("boc"); len(elem) >= l && elem[0:l] == "boc" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = DownloadBlockchainBlockBocOperation - r.summary = "" - r.operationID = "downloadBlockchainBlockBoc" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/blocks/{block_id}/boc" - r.args = args - r.count = 1 - return r, true - default: - return - } - } + case '/': // Prefix: "/raw" - case 't': // Prefix: "transactions" - - if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" { + if l := len("/raw"); len(elem) >= l && elem[0:l] == "/raw" { elem = elem[l:] } else { break @@ -5188,13 +5398,13 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetBlockchainBlockTransactionsOperation + r.name = GetRawBlockchainConfigOperation r.summary = "" - r.operationID = "getBlockchainBlockTransactions" + r.operationID = "getRawBlockchainConfig" r.operationGroup = "" - r.pathPattern = "/v2/blockchain/blocks/{block_id}/transactions" + r.pathPattern = "/v2/blockchain/config/raw" r.args = args - r.count = 1 + r.count = 0 return r, true default: return @@ -5203,108 +5413,43 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } - } - - case 'c': // Prefix: "config" - - if l := len("config"); len(elem) >= l && elem[0:l] == "config" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetBlockchainConfigOperation - r.summary = "" - r.operationID = "getBlockchainConfig" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/config" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '/': // Prefix: "/raw" + case 'l': // Prefix: "libraries/" - if l := len("/raw"); len(elem) >= l && elem[0:l] == "/raw" { + if l := len("libraries/"); len(elem) >= l && elem[0:l] == "libraries/" { elem = elem[l:] } else { break } + // Param: "hash" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + if len(elem) == 0 { // Leaf node. switch method { case "GET": - r.name = GetRawBlockchainConfigOperation + r.name = GetLibraryByHashOperation r.summary = "" - r.operationID = "getRawBlockchainConfig" + r.operationID = "getLibraryByHash" r.operationGroup = "" - r.pathPattern = "/v2/blockchain/config/raw" + r.pathPattern = "/v2/blockchain/libraries/{hash}" r.args = args - r.count = 0 + r.count = 1 return r, true default: return } } - } - - case 'l': // Prefix: "libraries/" - - if l := len("libraries/"); len(elem) >= l && elem[0:l] == "libraries/" { - elem = elem[l:] - } else { - break - } - - // Param: "hash" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetLibraryByHashOperation - r.summary = "" - r.operationID = "getLibraryByHash" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/libraries/{hash}" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - - case 'm': // Prefix: "m" - - if l := len("m"); len(elem) >= l && elem[0:l] == "m" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "asterchain" + case 'm': // Prefix: "m" - if l := len("asterchain"); len(elem) >= l && elem[0:l] == "asterchain" { + if l := len("m"); len(elem) >= l && elem[0:l] == "m" { elem = elem[l:] } else { break @@ -5314,52 +5459,43 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case '-': // Prefix: "-head" + case 'a': // Prefix: "asterchain" - if l := len("-head"); len(elem) >= l && elem[0:l] == "-head" { + if l := len("asterchain"); len(elem) >= l && elem[0:l] == "asterchain" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetBlockchainMasterchainHeadOperation - r.summary = "" - r.operationID = "getBlockchainMasterchainHead" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/masterchain-head" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - - case '/': // Prefix: "/" - - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { - elem = elem[l:] - } else { break } + switch elem[0] { + case '-': // Prefix: "-head" - // Param: "masterchain_seqno" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] + if l := len("-head"); len(elem) >= l && elem[0:l] == "-head" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetBlockchainMasterchainHeadOperation + r.summary = "" + r.operationID = "getBlockchainMasterchainHead" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/masterchain-head" + r.args = args + r.count = 0 + return r, true + default: + return + } + } - if len(elem) == 0 { - break - } - switch elem[0] { case '/': // Prefix: "/" if l := len("/"); len(elem) >= l && elem[0:l] == "/" { @@ -5368,62 +5504,135 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } + // Param: "masterchain_seqno" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + if len(elem) == 0 { break } switch elem[0] { - case 'b': // Prefix: "blocks" + case '/': // Prefix: "/" - if l := len("blocks"); len(elem) >= l && elem[0:l] == "blocks" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetBlockchainMasterchainBlocksOperation - r.summary = "" - r.operationID = "getBlockchainMasterchainBlocks" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/blocks" - r.args = args - r.count = 1 - return r, true - default: - return - } + break } + switch elem[0] { + case 'b': // Prefix: "blocks" - case 'c': // Prefix: "config" + if l := len("blocks"); len(elem) >= l && elem[0:l] == "blocks" { + elem = elem[l:] + } else { + break + } - if l := len("config"); len(elem) >= l && elem[0:l] == "config" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetBlockchainMasterchainBlocksOperation + r.summary = "" + r.operationID = "getBlockchainMasterchainBlocks" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/blocks" + r.args = args + r.count = 1 + return r, true + default: + return + } + } - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetBlockchainConfigFromBlockOperation - r.summary = "" - r.operationID = "getBlockchainConfigFromBlock" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/config" - r.args = args - r.count = 1 - return r, true - default: - return + case 'c': // Prefix: "config" + + if l := len("config"); len(elem) >= l && elem[0:l] == "config" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "GET": + r.name = GetBlockchainConfigFromBlockOperation + r.summary = "" + r.operationID = "getBlockchainConfigFromBlock" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/config" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/raw" + + if l := len("/raw"); len(elem) >= l && elem[0:l] == "/raw" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetRawBlockchainConfigFromBlockOperation + r.summary = "" + r.operationID = "getRawBlockchainConfigFromBlock" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/config/raw" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + } + + case 's': // Prefix: "shards" + + if l := len("shards"); len(elem) >= l && elem[0:l] == "shards" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetBlockchainMasterchainShardsOperation + r.summary = "" + r.operationID = "getBlockchainMasterchainShards" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/shards" + r.args = args + r.count = 1 + return r, true + default: + return + } } - } - switch elem[0] { - case '/': // Prefix: "/raw" - if l := len("/raw"); len(elem) >= l && elem[0:l] == "/raw" { + case 't': // Prefix: "transactions" + + if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" { elem = elem[l:] } else { break @@ -5433,11 +5642,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetRawBlockchainConfigFromBlockOperation + r.name = GetBlockchainMasterchainTransactionsOperation r.summary = "" - r.operationID = "getRawBlockchainConfigFromBlock" + r.operationID = "getBlockchainMasterchainTransactions" r.operationGroup = "" - r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/config/raw" + r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/transactions" r.args = args r.count = 1 return r, true @@ -5448,34 +5657,58 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } - case 's': // Prefix: "shards" + } - if l := len("shards"); len(elem) >= l && elem[0:l] == "shards" { - elem = elem[l:] - } else { - break - } + } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetBlockchainMasterchainShardsOperation - r.summary = "" - r.operationID = "getBlockchainMasterchainShards" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/shards" - r.args = args - r.count = 1 - return r, true - default: - return - } - } + case 'e': // Prefix: "essage" + + if l := len("essage"); len(elem) >= l && elem[0:l] == "essage" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + switch method { + case "POST": + r.name = SendBlockchainMessageOperation + r.summary = "" + r.operationID = "sendBlockchainMessage" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/message" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + switch elem[0] { + case 's': // Prefix: "s/" + + if l := len("s/"); len(elem) >= l && elem[0:l] == "s/" { + elem = elem[l:] + } else { + break + } + + // Param: "msg_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] - case 't': // Prefix: "transactions" + if len(elem) == 0 { + break + } + switch elem[0] { + case '/': // Prefix: "/transaction" - if l := len("transactions"); len(elem) >= l && elem[0:l] == "transactions" { + if l := len("/transaction"); len(elem) >= l && elem[0:l] == "/transaction" { elem = elem[l:] } else { break @@ -5485,11 +5718,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetBlockchainMasterchainTransactionsOperation + r.name = GetBlockchainTransactionByMessageHashOperation r.summary = "" - r.operationID = "getBlockchainMasterchainTransactions" + r.operationID = "getBlockchainTransactionByMessageHash" r.operationGroup = "" - r.pathPattern = "/v2/blockchain/masterchain/{masterchain_seqno}/transactions" + r.pathPattern = "/v2/blockchain/messages/{msg_id}/transaction" r.args = args r.count = 1 return r, true @@ -5504,22 +5737,23 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } - case 'e': // Prefix: "essage" + case 'r': // Prefix: "reduced/blocks" - if l := len("essage"); len(elem) >= l && elem[0:l] == "essage" { + if l := len("reduced/blocks"); len(elem) >= l && elem[0:l] == "reduced/blocks" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch method { - case "POST": - r.name = SendBlockchainMessageOperation + case "GET": + r.name = GetReducedBlockchainBlocksOperation r.summary = "" - r.operationID = "sendBlockchainMessage" + r.operationID = "getReducedBlockchainBlocks" r.operationGroup = "" - r.pathPattern = "/v2/blockchain/message" + r.pathPattern = "/v2/blockchain/reduced/blocks" r.args = args r.count = 0 return r, true @@ -5527,110 +5761,124 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { return } } - switch elem[0] { - case 's': // Prefix: "s/" - if l := len("s/"); len(elem) >= l && elem[0:l] == "s/" { - elem = elem[l:] - } else { - break - } + case 't': // Prefix: "transactions/" - // Param: "msg_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] + if l := len("transactions/"); len(elem) >= l && elem[0:l] == "transactions/" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break + // Param: "transaction_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetBlockchainTransactionOperation + r.summary = "" + r.operationID = "getBlockchainTransaction" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/transactions/{transaction_id}" + r.args = args + r.count = 1 + return r, true + default: + return } - switch elem[0] { - case '/': // Prefix: "/transaction" + } - if l := len("/transaction"); len(elem) >= l && elem[0:l] == "/transaction" { - elem = elem[l:] - } else { - break - } + case 'v': // Prefix: "validators" - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetBlockchainTransactionByMessageHashOperation - r.summary = "" - r.operationID = "getBlockchainTransactionByMessageHash" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/messages/{msg_id}/transaction" - r.args = args - r.count = 1 - return r, true - default: - return - } - } + if l := len("validators"); len(elem) >= l && elem[0:l] == "validators" { + elem = elem[l:] + } else { + break + } + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetBlockchainValidatorsOperation + r.summary = "" + r.operationID = "getBlockchainValidators" + r.operationGroup = "" + r.pathPattern = "/v2/blockchain/validators" + r.args = args + r.count = 0 + return r, true + default: + return } - } } - case 'r': // Prefix: "reduced/blocks" + case 'd': // Prefix: "dns/" - if l := len("reduced/blocks"); len(elem) >= l && elem[0:l] == "reduced/blocks" { + if l := len("dns/"); len(elem) >= l && elem[0:l] == "dns/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetReducedBlockchainBlocksOperation - r.summary = "" - r.operationID = "getReducedBlockchainBlocks" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/reduced/blocks" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } + switch elem[0] { + case 'a': // Prefix: "auctions" + origElem := elem + if l := len("auctions"); len(elem) >= l && elem[0:l] == "auctions" { + elem = elem[l:] + } else { + break + } - case 't': // Prefix: "transactions/" + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetAllAuctionsOperation + r.summary = "" + r.operationID = "getAllAuctions" + r.operationGroup = "" + r.pathPattern = "/v2/dns/auctions" + r.args = args + r.count = 0 + return r, true + default: + return + } + } - if l := len("transactions/"); len(elem) >= l && elem[0:l] == "transactions/" { - elem = elem[l:] - } else { - break + elem = origElem } - - // Param: "transaction_id" - // Leaf parameter, slashes are prohibited + // Param: "domain_name" + // Match until "/" idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break + if idx < 0 { + idx = len(elem) } - args[0] = elem - elem = "" + args[0] = elem[:idx] + elem = elem[idx:] if len(elem) == 0 { - // Leaf node. switch method { case "GET": - r.name = GetBlockchainTransactionOperation + r.name = GetDnsInfoOperation r.summary = "" - r.operationID = "getBlockchainTransaction" + r.operationID = "getDnsInfo" r.operationGroup = "" - r.pathPattern = "/v2/blockchain/transactions/{transaction_id}" + r.pathPattern = "/v2/dns/{domain_name}" r.args = args r.count = 1 return r, true @@ -5638,101 +5886,76 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { return } } + switch elem[0] { + case '/': // Prefix: "/" - case 'v': // Prefix: "validators" - - if l := len("validators"); len(elem) >= l && elem[0:l] == "validators" { - elem = elem[l:] - } else { - break - } + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetBlockchainValidatorsOperation - r.summary = "" - r.operationID = "getBlockchainValidators" - r.operationGroup = "" - r.pathPattern = "/v2/blockchain/validators" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + break } - } + switch elem[0] { + case 'b': // Prefix: "bids" - } + if l := len("bids"); len(elem) >= l && elem[0:l] == "bids" { + elem = elem[l:] + } else { + break + } - case 'd': // Prefix: "dns/" + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetDomainBidsOperation + r.summary = "" + r.operationID = "getDomainBids" + r.operationGroup = "" + r.pathPattern = "/v2/dns/{domain_name}/bids" + r.args = args + r.count = 1 + return r, true + default: + return + } + } - if l := len("dns/"); len(elem) >= l && elem[0:l] == "dns/" { - elem = elem[l:] - } else { - break - } + case 'r': // Prefix: "resolve" - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "auctions" - origElem := elem - if l := len("auctions"); len(elem) >= l && elem[0:l] == "auctions" { - elem = elem[l:] - } else { - break - } + if l := len("resolve"); len(elem) >= l && elem[0:l] == "resolve" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetAllAuctionsOperation - r.summary = "" - r.operationID = "getAllAuctions" - r.operationGroup = "" - r.pathPattern = "/v2/dns/auctions" - r.args = args - r.count = 0 - return r, true - default: - return - } - } + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = DnsResolveOperation + r.summary = "" + r.operationID = "dnsResolve" + r.operationGroup = "" + r.pathPattern = "/v2/dns/{domain_name}/resolve" + r.args = args + r.count = 1 + return r, true + default: + return + } + } - elem = origElem - } - // Param: "domain_name" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] + } - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetDnsInfoOperation - r.summary = "" - r.operationID = "getDnsInfo" - r.operationGroup = "" - r.pathPattern = "/v2/dns/{domain_name}" - r.args = args - r.count = 1 - return r, true - default: - return } - } - switch elem[0] { - case '/': // Prefix: "/" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + case 'e': // Prefix: "e" + + if l := len("e"); len(elem) >= l && elem[0:l] == "e" { elem = elem[l:] } else { break @@ -5742,23 +5965,62 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'b': // Prefix: "bids" + case 'v': // Prefix: "vents/" - if l := len("bids"); len(elem) >= l && elem[0:l] == "bids" { + if l := len("vents/"); len(elem) >= l && elem[0:l] == "vents/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. + break + } + switch elem[0] { + case 'e': // Prefix: "emulate" + origElem := elem + if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = EmulateMessageToEventOperation + r.summary = "" + r.operationID = "emulateMessageToEvent" + r.operationGroup = "" + r.pathPattern = "/v2/events/emulate" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + elem = origElem + } + // Param: "event_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { switch method { case "GET": - r.name = GetDomainBidsOperation + r.name = GetEventOperation r.summary = "" - r.operationID = "getDomainBids" + r.operationID = "getEvent" r.operationGroup = "" - r.pathPattern = "/v2/dns/{domain_name}/bids" + r.pathPattern = "/v2/events/{event_id}" r.args = args r.count = 1 return r, true @@ -5766,24 +6028,60 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { return } } + switch elem[0] { + case '/': // Prefix: "/jettons" + + if l := len("/jettons"); len(elem) >= l && elem[0:l] == "/jettons" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetJettonsEventsOperation + r.summary = "" + r.operationID = "getJettonsEvents" + r.operationGroup = "" + r.pathPattern = "/v2/events/{event_id}/jettons" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + } - case 'r': // Prefix: "resolve" + case 'x': // Prefix: "xtra-currency/" - if l := len("resolve"); len(elem) >= l && elem[0:l] == "resolve" { + if l := len("xtra-currency/"); len(elem) >= l && elem[0:l] == "xtra-currency/" { elem = elem[l:] } else { break } + // Param: "id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + if len(elem) == 0 { // Leaf node. switch method { case "GET": - r.name = DnsResolveOperation + r.name = GetExtraCurrencyInfoOperation r.summary = "" - r.operationID = "dnsResolve" + r.operationID = "getExtraCurrencyInfo" r.operationGroup = "" - r.pathPattern = "/v2/dns/{domain_name}/resolve" + r.pathPattern = "/v2/extra-currency/{id}" r.args = args r.count = 1 return r, true @@ -5794,23 +6092,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } - } - - case 'e': // Prefix: "e" - - if l := len("e"); len(elem) >= l && elem[0:l] == "e" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'v': // Prefix: "vents/" + case 'g': // Prefix: "gasless/" - if l := len("vents/"); len(elem) >= l && elem[0:l] == "vents/" { + if l := len("gasless/"); len(elem) >= l && elem[0:l] == "gasless/" { elem = elem[l:] } else { break @@ -5820,9 +6104,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'e': // Prefix: "emulate" - origElem := elem - if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { + case 'c': // Prefix: "config" + + if l := len("config"); len(elem) >= l && elem[0:l] == "config" { elem = elem[l:] } else { break @@ -5831,12 +6115,12 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { if len(elem) == 0 { // Leaf node. switch method { - case "POST": - r.name = EmulateMessageToEventOperation + case "GET": + r.name = GaslessConfigOperation r.summary = "" - r.operationID = "emulateMessageToEvent" + r.operationID = "gaslessConfig" r.operationGroup = "" - r.pathPattern = "/v2/events/emulate" + r.pathPattern = "/v2/gasless/config" r.args = args r.count = 0 return r, true @@ -5845,233 +6129,43 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } - elem = origElem - } - // Param: "event_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] - - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetEventOperation - r.summary = "" - r.operationID = "getEvent" - r.operationGroup = "" - r.pathPattern = "/v2/events/{event_id}" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - switch elem[0] { - case '/': // Prefix: "/jettons" + case 'e': // Prefix: "estimate/" - if l := len("/jettons"); len(elem) >= l && elem[0:l] == "/jettons" { + if l := len("estimate/"); len(elem) >= l && elem[0:l] == "estimate/" { elem = elem[l:] } else { break } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetJettonsEventsOperation - r.summary = "" - r.operationID = "getJettonsEvents" - r.operationGroup = "" - r.pathPattern = "/v2/events/{event_id}/jettons" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - - } - - case 'x': // Prefix: "xtra-currency/" - - if l := len("xtra-currency/"); len(elem) >= l && elem[0:l] == "xtra-currency/" { - elem = elem[l:] - } else { - break - } - - // Param: "id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetExtraCurrencyInfoOperation - r.summary = "" - r.operationID = "getExtraCurrencyInfo" - r.operationGroup = "" - r.pathPattern = "/v2/extra-currency/{id}" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - - } - - case 'g': // Prefix: "gasless/" - - if l := len("gasless/"); len(elem) >= l && elem[0:l] == "gasless/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'c': // Prefix: "config" - - if l := len("config"); len(elem) >= l && elem[0:l] == "config" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GaslessConfigOperation - r.summary = "" - r.operationID = "gaslessConfig" - r.operationGroup = "" - r.pathPattern = "/v2/gasless/config" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - - case 'e': // Prefix: "estimate/" - - if l := len("estimate/"); len(elem) >= l && elem[0:l] == "estimate/" { - elem = elem[l:] - } else { - break - } - - // Param: "master_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf node. - switch method { - case "POST": - r.name = GaslessEstimateOperation - r.summary = "" - r.operationID = "gaslessEstimate" - r.operationGroup = "" - r.pathPattern = "/v2/gasless/estimate/{master_id}" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - - case 's': // Prefix: "send" - - if l := len("send"); len(elem) >= l && elem[0:l] == "send" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "POST": - r.name = GaslessSendOperation - r.summary = "" - r.operationID = "gaslessSend" - r.operationGroup = "" - r.pathPattern = "/v2/gasless/send" - r.args = args - r.count = 0 - return r, true - default: - return + // Param: "master_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break } - } - - } - - case 'j': // Prefix: "jettons" - - if l := len("jettons"); len(elem) >= l && elem[0:l] == "jettons" { - elem = elem[l:] - } else { - break - } + args[0] = elem + elem = "" - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetJettonsOperation - r.summary = "" - r.operationID = "getJettons" - r.operationGroup = "" - r.pathPattern = "/v2/jettons" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '/': // Prefix: "/" + if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = GaslessEstimateOperation + r.summary = "" + r.operationID = "gaslessEstimate" + r.operationGroup = "" + r.pathPattern = "/v2/gasless/estimate/{master_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { - elem = elem[l:] - } else { - break - } + case 's': // Prefix: "send" - if len(elem) == 0 { - break - } - switch elem[0] { - case '_': // Prefix: "_bulk" - origElem := elem - if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { + if l := len("send"); len(elem) >= l && elem[0:l] == "send" { elem = elem[l:] } else { break @@ -6081,11 +6175,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "POST": - r.name = GetJettonInfosByAddressesOperation + r.name = GaslessSendOperation r.summary = "" - r.operationID = "getJettonInfosByAddresses" + r.operationID = "gaslessSend" r.operationGroup = "" - r.pathPattern = "/v2/jettons/_bulk" + r.pathPattern = "/v2/gasless/send" r.args = args r.count = 0 return r, true @@ -6094,27 +6188,26 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } - elem = origElem } - // Param: "jetton_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) + + case 'j': // Prefix: "jettons" + + if l := len("jettons"); len(elem) >= l && elem[0:l] == "jettons" { + elem = elem[l:] + } else { + break } - args[0] = elem[:idx] - elem = elem[idx:] if len(elem) == 0 { switch method { case "GET": - r.name = GetJettonInfoOperation + r.name = GetJettonsOperation r.summary = "" - r.operationID = "getJettonInfo" + r.operationID = "getJettons" r.operationGroup = "" - r.pathPattern = "/v2/jettons/{account_id}" + r.pathPattern = "/v2/jettons" r.args = args - r.count = 1 + r.count = 0 return r, true default: return @@ -6133,30 +6226,121 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'a': // Prefix: "accounts/" - - if l := len("accounts/"); len(elem) >= l && elem[0:l] == "accounts/" { + case '_': // Prefix: "_bulk" + origElem := elem + if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { elem = elem[l:] } else { break } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) + if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = GetJettonInfosByAddressesOperation + r.summary = "" + r.operationID = "getJettonInfosByAddresses" + r.operationGroup = "" + r.pathPattern = "/v2/jettons/_bulk" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + elem = origElem + } + // Param: "jetton_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + switch method { + case "GET": + r.name = GetJettonInfoOperation + r.summary = "" + r.operationID = "getJettonInfo" + r.operationGroup = "" + r.pathPattern = "/v2/jettons/{account_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/" + + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break } - args[1] = elem[:idx] - elem = elem[idx:] if len(elem) == 0 { break } switch elem[0] { - case '/': // Prefix: "/history" + case 'a': // Prefix: "accounts/" + + if l := len("accounts/"); len(elem) >= l && elem[0:l] == "accounts/" { + elem = elem[l:] + } else { + break + } + + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[1] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + break + } + switch elem[0] { + case '/': // Prefix: "/history" + + if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetJettonAccountHistoryByIDOperation + r.summary = "" + r.operationID = "getJettonAccountHistoryByID" + r.operationGroup = "" + r.pathPattern = "/v2/jettons/{jetton_id}/accounts/{account_id}/history" + r.args = args + r.count = 2 + return r, true + default: + return + } + } + + } - if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + case 'h': // Prefix: "holders" + + if l := len("holders"); len(elem) >= l && elem[0:l] == "holders" { elem = elem[l:] } else { break @@ -6166,145 +6350,309 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetJettonAccountHistoryByIDOperation + r.name = GetJettonHoldersOperation r.summary = "" - r.operationID = "getJettonAccountHistoryByID" + r.operationID = "getJettonHolders" r.operationGroup = "" - r.pathPattern = "/v2/jettons/{jetton_id}/accounts/{account_id}/history" + r.pathPattern = "/v2/jettons/{account_id}/holders" r.args = args - r.count = 2 + r.count = 1 return r, true default: return } } + case 't': // Prefix: "transfer/" + + if l := len("transfer/"); len(elem) >= l && elem[0:l] == "transfer/" { + elem = elem[l:] + } else { + break + } + + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[1] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + break + } + switch elem[0] { + case '/': // Prefix: "/payload" + + if l := len("/payload"); len(elem) >= l && elem[0:l] == "/payload" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetJettonTransferPayloadOperation + r.summary = "" + r.operationID = "getJettonTransferPayload" + r.operationGroup = "" + r.pathPattern = "/v2/jettons/{jetton_id}/transfer/{account_id}/payload" + r.args = args + r.count = 2 + return r, true + default: + return + } + } + + } + } - case 'h': // Prefix: "holders" + } + + } + + case 'l': // Prefix: "liteserver/" + + if l := len("liteserver/"); len(elem) >= l && elem[0:l] == "liteserver/" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'g': // Prefix: "get_" + + if l := len("get_"); len(elem) >= l && elem[0:l] == "get_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "a" - if l := len("holders"); len(elem) >= l && elem[0:l] == "holders" { + if l := len("a"); len(elem) >= l && elem[0:l] == "a" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetJettonHoldersOperation - r.summary = "" - r.operationID = "getJettonHolders" - r.operationGroup = "" - r.pathPattern = "/v2/jettons/{account_id}/holders" - r.args = args - r.count = 1 - return r, true - default: - return + break + } + switch elem[0] { + case 'c': // Prefix: "ccount_state/" + + if l := len("ccount_state/"); len(elem) >= l && elem[0:l] == "ccount_state/" { + elem = elem[l:] + } else { + break + } + + // Param: "account_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetRawAccountStateOperation + r.summary = "" + r.operationID = "getRawAccountState" + r.operationGroup = "" + r.pathPattern = "/v2/liteserver/get_account_state/{account_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + case 'l': // Prefix: "ll_shards_info/" + + if l := len("ll_shards_info/"); len(elem) >= l && elem[0:l] == "ll_shards_info/" { + elem = elem[l:] + } else { + break + } + + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetAllRawShardsInfoOperation + r.summary = "" + r.operationID = "getAllRawShardsInfo" + r.operationGroup = "" + r.pathPattern = "/v2/liteserver/get_all_shards_info/{block_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } } + } - case 't': // Prefix: "transfer/" + case 'b': // Prefix: "block" - if l := len("transfer/"); len(elem) >= l && elem[0:l] == "transfer/" { + if l := len("block"); len(elem) >= l && elem[0:l] == "block" { elem = elem[l:] } else { break } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[1] = elem[:idx] - elem = elem[idx:] - if len(elem) == 0 { break } switch elem[0] { - case '/': // Prefix: "/payload" + case '/': // Prefix: "/" - if l := len("/payload"); len(elem) >= l && elem[0:l] == "/payload" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + if len(elem) == 0 { // Leaf node. switch method { case "GET": - r.name = GetJettonTransferPayloadOperation + r.name = GetRawBlockchainBlockOperation r.summary = "" - r.operationID = "getJettonTransferPayload" + r.operationID = "getRawBlockchainBlock" r.operationGroup = "" - r.pathPattern = "/v2/jettons/{jetton_id}/transfer/{account_id}/payload" + r.pathPattern = "/v2/liteserver/get_block/{block_id}" r.args = args - r.count = 2 + r.count = 1 return r, true default: return } } - } + case '_': // Prefix: "_" - } + if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + elem = elem[l:] + } else { + break + } - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'h': // Prefix: "header/" - } + if l := len("header/"); len(elem) >= l && elem[0:l] == "header/" { + elem = elem[l:] + } else { + break + } - case 'l': // Prefix: "liteserver/" + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" - if l := len("liteserver/"); len(elem) >= l && elem[0:l] == "liteserver/" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetRawBlockchainBlockHeaderOperation + r.summary = "" + r.operationID = "getRawBlockchainBlockHeader" + r.operationGroup = "" + r.pathPattern = "/v2/liteserver/get_block_header/{block_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'g': // Prefix: "get_" + case 'p': // Prefix: "proof" - if l := len("get_"); len(elem) >= l && elem[0:l] == "get_" { - elem = elem[l:] - } else { - break - } + if l := len("proof"); len(elem) >= l && elem[0:l] == "proof" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "a" + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetRawBlockProofOperation + r.summary = "" + r.operationID = "getRawBlockProof" + r.operationGroup = "" + r.pathPattern = "/v2/liteserver/get_block_proof" + r.args = args + r.count = 0 + return r, true + default: + return + } + } - if l := len("a"); len(elem) >= l && elem[0:l] == "a" { - elem = elem[l:] - } else { - break - } + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'c': // Prefix: "ccount_state/" + } - if l := len("ccount_state/"); len(elem) >= l && elem[0:l] == "ccount_state/" { + case 'c': // Prefix: "config_all/" + + if l := len("config_all/"); len(elem) >= l && elem[0:l] == "config_all/" { elem = elem[l:] } else { break } - // Param: "account_id" + // Param: "block_id" // Leaf parameter, slashes are prohibited idx := strings.IndexByte(elem, '/') if idx >= 0 { @@ -6317,11 +6665,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetRawAccountStateOperation + r.name = GetRawConfigOperation r.summary = "" - r.operationID = "getRawAccountState" + r.operationID = "getRawConfig" r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_account_state/{account_id}" + r.pathPattern = "/v2/liteserver/get_config_all/{block_id}" r.args = args r.count = 1 return r, true @@ -6330,91 +6678,215 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } - case 'l': // Prefix: "ll_shards_info/" + case 'm': // Prefix: "masterchain_info" - if l := len("ll_shards_info/"); len(elem) >= l && elem[0:l] == "ll_shards_info/" { + if l := len("masterchain_info"); len(elem) >= l && elem[0:l] == "masterchain_info" { elem = elem[l:] } else { break } - // Param: "block_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - if len(elem) == 0 { - // Leaf node. switch method { case "GET": - r.name = GetAllRawShardsInfoOperation + r.name = GetRawMasterchainInfoOperation r.summary = "" - r.operationID = "getAllRawShardsInfo" + r.operationID = "getRawMasterchainInfo" r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_all_shards_info/{block_id}" + r.pathPattern = "/v2/liteserver/get_masterchain_info" r.args = args - r.count = 1 + r.count = 0 return r, true default: return } } + switch elem[0] { + case '_': // Prefix: "_ext" - } + if l := len("_ext"); len(elem) >= l && elem[0:l] == "_ext" { + elem = elem[l:] + } else { + break + } - case 'b': // Prefix: "block" + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetRawMasterchainInfoExtOperation + r.summary = "" + r.operationID = "getRawMasterchainInfoExt" + r.operationGroup = "" + r.pathPattern = "/v2/liteserver/get_masterchain_info_ext" + r.args = args + r.count = 0 + return r, true + default: + return + } + } - if l := len("block"); len(elem) >= l && elem[0:l] == "block" { - elem = elem[l:] - } else { - break - } + } - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/" + case 'o': // Prefix: "out_msg_queue_sizes" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + if l := len("out_msg_queue_sizes"); len(elem) >= l && elem[0:l] == "out_msg_queue_sizes" { elem = elem[l:] } else { break } - // Param: "block_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - if len(elem) == 0 { // Leaf node. switch method { case "GET": - r.name = GetRawBlockchainBlockOperation + r.name = GetOutMsgQueueSizesOperation r.summary = "" - r.operationID = "getRawBlockchainBlock" + r.operationID = "getOutMsgQueueSizes" r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_block/{block_id}" + r.pathPattern = "/v2/liteserver/get_out_msg_queue_sizes" r.args = args - r.count = 1 + r.count = 0 return r, true default: return } } - case '_': // Prefix: "_" + case 's': // Prefix: "s" + + if l := len("s"); len(elem) >= l && elem[0:l] == "s" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'h': // Prefix: "hard_" + + if l := len("hard_"); len(elem) >= l && elem[0:l] == "hard_" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'b': // Prefix: "block_proof/" + + if l := len("block_proof/"); len(elem) >= l && elem[0:l] == "block_proof/" { + elem = elem[l:] + } else { + break + } + + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetRawShardBlockProofOperation + r.summary = "" + r.operationID = "getRawShardBlockProof" + r.operationGroup = "" + r.pathPattern = "/v2/liteserver/get_shard_block_proof/{block_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + case 'i': // Prefix: "info/" + + if l := len("info/"); len(elem) >= l && elem[0:l] == "info/" { + elem = elem[l:] + } else { + break + } + + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetRawShardInfoOperation + r.summary = "" + r.operationID = "getRawShardInfo" + r.operationGroup = "" + r.pathPattern = "/v2/liteserver/get_shard_info/{block_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + } + + case 't': // Prefix: "tate/" + + if l := len("tate/"); len(elem) >= l && elem[0:l] == "tate/" { + elem = elem[l:] + } else { + break + } + + // Param: "block_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetRawBlockchainBlockStateOperation + r.summary = "" + r.operationID = "getRawBlockchainBlockState" + r.operationGroup = "" + r.pathPattern = "/v2/liteserver/get_state/{block_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + } + + case 't': // Prefix: "t" - if l := len("_"); len(elem) >= l && elem[0:l] == "_" { + if l := len("t"); len(elem) >= l && elem[0:l] == "t" { elem = elem[l:] } else { break @@ -6424,59 +6896,59 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'h': // Prefix: "header/" + case 'i': // Prefix: "ime" - if l := len("header/"); len(elem) >= l && elem[0:l] == "header/" { + if l := len("ime"); len(elem) >= l && elem[0:l] == "ime" { elem = elem[l:] } else { break } - // Param: "block_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - if len(elem) == 0 { // Leaf node. switch method { case "GET": - r.name = GetRawBlockchainBlockHeaderOperation + r.name = GetRawTimeOperation r.summary = "" - r.operationID = "getRawBlockchainBlockHeader" + r.operationID = "getRawTime" r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_block_header/{block_id}" + r.pathPattern = "/v2/liteserver/get_time" r.args = args - r.count = 1 + r.count = 0 return r, true default: return } } - case 'p': // Prefix: "proof" + case 'r': // Prefix: "ransactions/" - if l := len("proof"); len(elem) >= l && elem[0:l] == "proof" { + if l := len("ransactions/"); len(elem) >= l && elem[0:l] == "ransactions/" { elem = elem[l:] } else { break } + // Param: "account_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + if len(elem) == 0 { // Leaf node. switch method { case "GET": - r.name = GetRawBlockProofOperation + r.name = GetRawTransactionsOperation r.summary = "" - r.operationID = "getRawBlockProof" + r.operationID = "getRawTransactions" r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_block_proof" + r.pathPattern = "/v2/liteserver/get_transactions/{account_id}" r.args = args - r.count = 0 + r.count = 1 return r, true default: return @@ -6487,9 +6959,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } - case 'c': // Prefix: "config_all/" + case 'l': // Prefix: "list_block_transactions/" - if l := len("config_all/"); len(elem) >= l && elem[0:l] == "config_all/" { + if l := len("list_block_transactions/"); len(elem) >= l && elem[0:l] == "list_block_transactions/" { elem = elem[l:] } else { break @@ -6508,11 +6980,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetRawConfigOperation + r.name = GetRawListBlockTransactionsOperation r.summary = "" - r.operationID = "getRawConfig" + r.operationID = "getRawListBlockTransactions" r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_config_all/{block_id}" + r.pathPattern = "/v2/liteserver/list_block_transactions/{block_id}" r.args = args r.count = 1 return r, true @@ -6521,22 +6993,23 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } - case 'm': // Prefix: "masterchain_info" + case 's': // Prefix: "send_message" - if l := len("masterchain_info"); len(elem) >= l && elem[0:l] == "masterchain_info" { + if l := len("send_message"); len(elem) >= l && elem[0:l] == "send_message" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. switch method { - case "GET": - r.name = GetRawMasterchainInfoOperation + case "POST": + r.name = SendRawMessageOperation r.summary = "" - r.operationID = "getRawMasterchainInfo" + r.operationID = "sendRawMessage" r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_masterchain_info" + r.pathPattern = "/v2/liteserver/send_message" r.args = args r.count = 0 return r, true @@ -6544,37 +7017,24 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { return } } - switch elem[0] { - case '_': // Prefix: "_ext" - if l := len("_ext"); len(elem) >= l && elem[0:l] == "_ext" { - elem = elem[l:] - } else { - break - } + } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetRawMasterchainInfoExtOperation - r.summary = "" - r.operationID = "getRawMasterchainInfoExt" - r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_masterchain_info_ext" - r.args = args - r.count = 0 - return r, true - default: - return - } - } + case 'm': // Prefix: "m" - } + if l := len("m"); len(elem) >= l && elem[0:l] == "m" { + elem = elem[l:] + } else { + break + } - case 'o': // Prefix: "out_msg_queue_sizes" + if len(elem) == 0 { + break + } + switch elem[0] { + case 'e': // Prefix: "essage/decode" - if l := len("out_msg_queue_sizes"); len(elem) >= l && elem[0:l] == "out_msg_queue_sizes" { + if l := len("essage/decode"); len(elem) >= l && elem[0:l] == "essage/decode" { elem = elem[l:] } else { break @@ -6583,12 +7043,12 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { if len(elem) == 0 { // Leaf node. switch method { - case "GET": - r.name = GetOutMsgQueueSizesOperation + case "POST": + r.name = DecodeMessageOperation r.summary = "" - r.operationID = "getOutMsgQueueSizes" + r.operationID = "decodeMessage" r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_out_msg_queue_sizes" + r.pathPattern = "/v2/message/decode" r.args = args r.count = 0 return r, true @@ -6597,9 +7057,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } - case 's': // Prefix: "s" + case 'u': // Prefix: "ultisig/" - if l := len("s"); len(elem) >= l && elem[0:l] == "s" { + if l := len("ultisig/"); len(elem) >= l && elem[0:l] == "ultisig/" { elem = elem[l:] } else { break @@ -6609,97 +7069,15 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'h': // Prefix: "hard_" - - if l := len("hard_"); len(elem) >= l && elem[0:l] == "hard_" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'b': // Prefix: "block_proof/" - - if l := len("block_proof/"); len(elem) >= l && elem[0:l] == "block_proof/" { - elem = elem[l:] - } else { - break - } - - // Param: "block_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetRawShardBlockProofOperation - r.summary = "" - r.operationID = "getRawShardBlockProof" - r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_shard_block_proof/{block_id}" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - - case 'i': // Prefix: "info/" - - if l := len("info/"); len(elem) >= l && elem[0:l] == "info/" { - elem = elem[l:] - } else { - break - } - - // Param: "block_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetRawShardInfoOperation - r.summary = "" - r.operationID = "getRawShardInfo" - r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_shard_info/{block_id}" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - - } - - case 't': // Prefix: "tate/" - - if l := len("tate/"); len(elem) >= l && elem[0:l] == "tate/" { + case 'o': // Prefix: "order/" + origElem := elem + if l := len("order/"); len(elem) >= l && elem[0:l] == "order/" { elem = elem[l:] } else { break } - // Param: "block_id" + // Param: "account_id" // Leaf parameter, slashes are prohibited idx := strings.IndexByte(elem, '/') if idx >= 0 { @@ -6712,11 +7090,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetRawBlockchainBlockStateOperation + r.name = GetMultisigOrderOperation r.summary = "" - r.operationID = "getRawBlockchainBlockState" + r.operationID = "getMultisigOrder" r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_state/{block_id}" + r.pathPattern = "/v2/multisig/order/{account_id}" r.args = args r.count = 1 return r, true @@ -6725,71 +7103,154 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } + elem = origElem + } + // Param: "account_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { + break + } + args[0] = elem + elem = "" + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetMultisigAccountOperation + r.summary = "" + r.operationID = "getMultisigAccount" + r.operationGroup = "" + r.pathPattern = "/v2/multisig/{account_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } } - case 't': // Prefix: "t" + } + + case 'n': // Prefix: "nfts/" + + if l := len("nfts/"); len(elem) >= l && elem[0:l] == "nfts/" { + elem = elem[l:] + } else { + break + } - if l := len("t"); len(elem) >= l && elem[0:l] == "t" { + if len(elem) == 0 { + break + } + switch elem[0] { + case '_': // Prefix: "_bulk" + origElem := elem + if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { elem = elem[l:] } else { break } if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = GetNftItemsByAddressesOperation + r.summary = "" + r.operationID = "getNftItemsByAddresses" + r.operationGroup = "" + r.pathPattern = "/v2/nfts/_bulk" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + elem = origElem + case 'c': // Prefix: "collections" + origElem := elem + if l := len("collections"); len(elem) >= l && elem[0:l] == "collections" { + elem = elem[l:] + } else { break } + + if len(elem) == 0 { + switch method { + case "GET": + r.name = GetNftCollectionsOperation + r.summary = "" + r.operationID = "getNftCollections" + r.operationGroup = "" + r.pathPattern = "/v2/nfts/collections" + r.args = args + r.count = 0 + return r, true + default: + return + } + } switch elem[0] { - case 'i': // Prefix: "ime" + case '/': // Prefix: "/" - if l := len("ime"); len(elem) >= l && elem[0:l] == "ime" { + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetRawTimeOperation - r.summary = "" - r.operationID = "getRawTime" - r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_time" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } + switch elem[0] { + case '_': // Prefix: "_bulk" + origElem := elem + if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { + elem = elem[l:] + } else { + break + } - case 'r': // Prefix: "ransactions/" + if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = GetNftCollectionItemsByAddressesOperation + r.summary = "" + r.operationID = "getNftCollectionItemsByAddresses" + r.operationGroup = "" + r.pathPattern = "/v2/nfts/collections/_bulk" + r.args = args + r.count = 0 + return r, true + default: + return + } + } - if l := len("ransactions/"); len(elem) >= l && elem[0:l] == "ransactions/" { - elem = elem[l:] - } else { - break + elem = origElem } - // Param: "account_id" - // Leaf parameter, slashes are prohibited + // Match until "/" idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break + if idx < 0 { + idx = len(elem) } - args[0] = elem - elem = "" + args[0] = elem[:idx] + elem = elem[idx:] if len(elem) == 0 { - // Leaf node. switch method { case "GET": - r.name = GetRawTransactionsOperation + r.name = GetNftCollectionOperation r.summary = "" - r.operationID = "getRawTransactions" + r.operationID = "getNftCollection" r.operationGroup = "" - r.pathPattern = "/v2/liteserver/get_transactions/{account_id}" + r.pathPattern = "/v2/nfts/collections/{account_id}" r.args = args r.count = 1 return r, true @@ -6797,37 +7258,55 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { return } } + switch elem[0] { + case '/': // Prefix: "/items" - } + if l := len("/items"); len(elem) >= l && elem[0:l] == "/items" { + elem = elem[l:] + } else { + break + } - } + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetItemsFromCollectionOperation + r.summary = "" + r.operationID = "getItemsFromCollection" + r.operationGroup = "" + r.pathPattern = "/v2/nfts/collections/{account_id}/items" + r.args = args + r.count = 1 + return r, true + default: + return + } + } - case 'l': // Prefix: "list_block_transactions/" + } - if l := len("list_block_transactions/"); len(elem) >= l && elem[0:l] == "list_block_transactions/" { - elem = elem[l:] - } else { - break - } + } - // Param: "block_id" - // Leaf parameter, slashes are prohibited + elem = origElem + } + // Param: "account_id" + // Match until "/" idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break + if idx < 0 { + idx = len(elem) } - args[0] = elem - elem = "" + args[0] = elem[:idx] + elem = elem[idx:] if len(elem) == 0 { - // Leaf node. switch method { case "GET": - r.name = GetRawListBlockTransactionsOperation + r.name = GetNftItemByAddressOperation r.summary = "" - r.operationID = "getRawListBlockTransactions" + r.operationID = "getNftItemByAddress" r.operationGroup = "" - r.pathPattern = "/v2/liteserver/list_block_transactions/{block_id}" + r.pathPattern = "/v2/nfts/{account_id}" r.args = args r.count = 1 return r, true @@ -6835,74 +7314,37 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { return } } + switch elem[0] { + case '/': // Prefix: "/history" - case 's': // Prefix: "send_message" - - if l := len("send_message"); len(elem) >= l && elem[0:l] == "send_message" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "POST": - r.name = SendRawMessageOperation - r.summary = "" - r.operationID = "sendRawMessage" - r.operationGroup = "" - r.pathPattern = "/v2/liteserver/send_message" - r.args = args - r.count = 0 - return r, true - default: - return + if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + elem = elem[l:] + } else { + break } - } - - } - - case 'm': // Prefix: "m" - - if l := len("m"); len(elem) >= l && elem[0:l] == "m" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'e': // Prefix: "essage/decode" - - if l := len("essage/decode"); len(elem) >= l && elem[0:l] == "essage/decode" { - elem = elem[l:] - } else { - break - } - if len(elem) == 0 { - // Leaf node. - switch method { - case "POST": - r.name = DecodeMessageOperation - r.summary = "" - r.operationID = "decodeMessage" - r.operationGroup = "" - r.pathPattern = "/v2/message/decode" - r.args = args - r.count = 0 - return r, true - default: - return + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetNftHistoryByIDOperation + r.summary = "" + r.operationID = "getNftHistoryByID" + r.operationGroup = "" + r.pathPattern = "/v2/nfts/{account_id}/history" + r.args = args + r.count = 1 + return r, true + default: + return + } } + } - case 'u': // Prefix: "ultisig/" + case 'o': // Prefix: "openapi." - if l := len("ultisig/"); len(elem) >= l && elem[0:l] == "ultisig/" { + if l := len("openapi."); len(elem) >= l && elem[0:l] == "openapi." { elem = elem[l:] } else { break @@ -6912,135 +7354,73 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'o': // Prefix: "order/" - origElem := elem - if l := len("order/"); len(elem) >= l && elem[0:l] == "order/" { + case 'j': // Prefix: "json" + + if l := len("json"); len(elem) >= l && elem[0:l] == "json" { elem = elem[l:] } else { break } - // Param: "account_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" - if len(elem) == 0 { // Leaf node. switch method { case "GET": - r.name = GetMultisigOrderOperation + r.name = GetOpenapiJsonOperation r.summary = "" - r.operationID = "getMultisigOrder" + r.operationID = "getOpenapiJson" r.operationGroup = "" - r.pathPattern = "/v2/multisig/order/{account_id}" + r.pathPattern = "/v2/openapi.json" r.args = args - r.count = 1 + r.count = 0 return r, true default: return } } - elem = origElem - } - // Param: "account_id" - // Leaf parameter, slashes are prohibited - idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break - } - args[0] = elem - elem = "" + case 'y': // Prefix: "yml" - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetMultisigAccountOperation - r.summary = "" - r.operationID = "getMultisigAccount" - r.operationGroup = "" - r.pathPattern = "/v2/multisig/{account_id}" - r.args = args - r.count = 1 - return r, true - default: - return + if l := len("yml"); len(elem) >= l && elem[0:l] == "yml" { + elem = elem[l:] + } else { + break } - } - - } - - case 'n': // Prefix: "nfts/" - if l := len("nfts/"); len(elem) >= l && elem[0:l] == "nfts/" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetOpenapiYmlOperation + r.summary = "" + r.operationID = "getOpenapiYml" + r.operationGroup = "" + r.pathPattern = "/v2/openapi.yml" + r.args = args + r.count = 0 + return r, true + default: + return + } + } - if len(elem) == 0 { - break - } - switch elem[0] { - case '_': // Prefix: "_bulk" - origElem := elem - if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { - elem = elem[l:] - } else { - break } - if len(elem) == 0 { - // Leaf node. - switch method { - case "POST": - r.name = GetNftItemsByAddressesOperation - r.summary = "" - r.operationID = "getNftItemsByAddresses" - r.operationGroup = "" - r.pathPattern = "/v2/nfts/_bulk" - r.args = args - r.count = 0 - return r, true - default: - return - } - } + case 'p': // Prefix: "pu" - elem = origElem - case 'c': // Prefix: "collections" - origElem := elem - if l := len("collections"); len(elem) >= l && elem[0:l] == "collections" { + if l := len("pu"); len(elem) >= l && elem[0:l] == "pu" { elem = elem[l:] } else { break } if len(elem) == 0 { - switch method { - case "GET": - r.name = GetNftCollectionsOperation - r.summary = "" - r.operationID = "getNftCollections" - r.operationGroup = "" - r.pathPattern = "/v2/nfts/collections" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } switch elem[0] { - case '/': // Prefix: "/" + case 'b': // Prefix: "bkeys/" - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + if l := len("bkeys/"); len(elem) >= l && elem[0:l] == "bkeys/" { elem = elem[l:] } else { break @@ -7050,9 +7430,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case '_': // Prefix: "_bulk" + case 'w': // Prefix: "wallets/_bulk" origElem := elem - if l := len("_bulk"); len(elem) >= l && elem[0:l] == "_bulk" { + if l := len("wallets/_bulk"); len(elem) >= l && elem[0:l] == "wallets/_bulk" { elem = elem[l:] } else { break @@ -7062,11 +7442,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "POST": - r.name = GetNftCollectionItemsByAddressesOperation + r.name = GetWalletsByPublicKeyBulkOperation r.summary = "" - r.operationID = "getNftCollectionItemsByAddresses" + r.operationID = "getWalletsByPublicKeyBulk" r.operationGroup = "" - r.pathPattern = "/v2/nfts/collections/_bulk" + r.pathPattern = "/v2/pubkeys/wallets/_bulk" r.args = args r.count = 0 return r, true @@ -7077,7 +7457,7 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { elem = origElem } - // Param: "account_id" + // Param: "public_key" // Match until "/" idx := strings.IndexByte(elem, '/') if idx < 0 { @@ -7087,24 +7467,12 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { elem = elem[idx:] if len(elem) == 0 { - switch method { - case "GET": - r.name = GetNftCollectionOperation - r.summary = "" - r.operationID = "getNftCollection" - r.operationGroup = "" - r.pathPattern = "/v2/nfts/collections/{account_id}" - r.args = args - r.count = 1 - return r, true - default: - return - } + break } switch elem[0] { - case '/': // Prefix: "/items" + case '/': // Prefix: "/wallets" - if l := len("/items"); len(elem) >= l && elem[0:l] == "/items" { + if l := len("/wallets"); len(elem) >= l && elem[0:l] == "/wallets" { elem = elem[l:] } else { break @@ -7114,11 +7482,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetItemsFromCollectionOperation + r.name = GetWalletsByPublicKeyOperation r.summary = "" - r.operationID = "getItemsFromCollection" + r.operationID = "getWalletsByPublicKey" r.operationGroup = "" - r.pathPattern = "/v2/nfts/collections/{account_id}/items" + r.pathPattern = "/v2/pubkeys/{public_key}/wallets" r.args = args r.count = 1 return r, true @@ -7129,116 +7497,72 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } - } - - elem = origElem - } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] - - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetNftItemByAddressOperation - r.summary = "" - r.operationID = "getNftItemByAddress" - r.operationGroup = "" - r.pathPattern = "/v2/nfts/{account_id}" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - switch elem[0] { - case '/': // Prefix: "/history" - - if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { - elem = elem[l:] - } else { - break - } + case 'r': // Prefix: "rchases/" - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetNftHistoryByIDOperation - r.summary = "" - r.operationID = "getNftHistoryByID" - r.operationGroup = "" - r.pathPattern = "/v2/nfts/{account_id}/history" - r.args = args - r.count = 1 - return r, true - default: - return + if l := len("rchases/"); len(elem) >= l && elem[0:l] == "rchases/" { + elem = elem[l:] + } else { + break } - } - - } - case 'o': // Prefix: "openapi." - - if l := len("openapi."); len(elem) >= l && elem[0:l] == "openapi." { - elem = elem[l:] - } else { - break - } + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] - if len(elem) == 0 { - break - } - switch elem[0] { - case 'j': // Prefix: "json" + if len(elem) == 0 { + break + } + switch elem[0] { + case '/': // Prefix: "/history" - if l := len("json"); len(elem) >= l && elem[0:l] == "json" { - elem = elem[l:] - } else { - break - } + if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetPurchaseHistoryOperation + r.summary = "" + r.operationID = "getPurchaseHistory" + r.operationGroup = "" + r.pathPattern = "/v2/purchases/{account_id}/history" + r.args = args + r.count = 1 + return r, true + default: + return + } + } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetOpenapiJsonOperation - r.summary = "" - r.operationID = "getOpenapiJson" - r.operationGroup = "" - r.pathPattern = "/v2/openapi.json" - r.args = args - r.count = 0 - return r, true - default: - return } + } - case 'y': // Prefix: "yml" + case 'r': // Prefix: "rates" - if l := len("yml"); len(elem) >= l && elem[0:l] == "yml" { + if l := len("rates"); len(elem) >= l && elem[0:l] == "rates" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. switch method { case "GET": - r.name = GetOpenapiYmlOperation + r.name = GetRatesOperation r.summary = "" - r.operationID = "getOpenapiYml" + r.operationID = "getRates" r.operationGroup = "" - r.pathPattern = "/v2/openapi.yml" + r.pathPattern = "/v2/rates" r.args = args r.count = 0 return r, true @@ -7246,214 +7570,288 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { return } } - - } - - case 'p': // Prefix: "pu" - - if l := len("pu"); len(elem) >= l && elem[0:l] == "pu" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'b': // Prefix: "bkeys/" - - if l := len("bkeys/"); len(elem) >= l && elem[0:l] == "bkeys/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } switch elem[0] { - case 'w': // Prefix: "wallets/_bulk" - origElem := elem - if l := len("wallets/_bulk"); len(elem) >= l && elem[0:l] == "wallets/_bulk" { + case '/': // Prefix: "/" + + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch method { - case "POST": - r.name = GetWalletsByPublicKeyBulkOperation - r.summary = "" - r.operationID = "getWalletsByPublicKeyBulk" - r.operationGroup = "" - r.pathPattern = "/v2/pubkeys/wallets/_bulk" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } + switch elem[0] { + case 'c': // Prefix: "chart" - elem = origElem - } - // Param: "public_key" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] + if l := len("chart"); len(elem) >= l && elem[0:l] == "chart" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/wallets" + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetChartRatesOperation + r.summary = "" + r.operationID = "getChartRates" + r.operationGroup = "" + r.pathPattern = "/v2/rates/chart" + r.args = args + r.count = 0 + return r, true + default: + return + } + } - if l := len("/wallets"); len(elem) >= l && elem[0:l] == "/wallets" { - elem = elem[l:] - } else { - break - } + case 'm': // Prefix: "markets" - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetWalletsByPublicKeyOperation - r.summary = "" - r.operationID = "getWalletsByPublicKey" - r.operationGroup = "" - r.pathPattern = "/v2/pubkeys/{public_key}/wallets" - r.args = args - r.count = 1 - return r, true - default: - return + if l := len("markets"); len(elem) >= l && elem[0:l] == "markets" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetMarketsRatesOperation + r.summary = "" + r.operationID = "getMarketsRates" + r.operationGroup = "" + r.pathPattern = "/v2/rates/markets" + r.args = args + r.count = 0 + return r, true + default: + return + } } + } } - case 'r': // Prefix: "rchases/" + case 's': // Prefix: "st" - if l := len("rchases/"); len(elem) >= l && elem[0:l] == "rchases/" { + if l := len("st"); len(elem) >= l && elem[0:l] == "st" { elem = elem[l:] } else { break } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] - if len(elem) == 0 { break } switch elem[0] { - case '/': // Prefix: "/history" + case 'a': // Prefix: "a" - if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + if l := len("a"); len(elem) >= l && elem[0:l] == "a" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetPurchaseHistoryOperation - r.summary = "" - r.operationID = "getPurchaseHistory" - r.operationGroup = "" - r.pathPattern = "/v2/purchases/{account_id}/history" - r.args = args - r.count = 1 - return r, true - default: - return - } + break } + switch elem[0] { + case 'k': // Prefix: "king/" + + if l := len("king/"); len(elem) >= l && elem[0:l] == "king/" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case 'n': // Prefix: "nominator/" + + if l := len("nominator/"); len(elem) >= l && elem[0:l] == "nominator/" { + elem = elem[l:] + } else { + break + } + + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + break + } + switch elem[0] { + case '/': // Prefix: "/pools" + + if l := len("/pools"); len(elem) >= l && elem[0:l] == "/pools" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetAccountNominatorsPoolsOperation + r.summary = "" + r.operationID = "getAccountNominatorsPools" + r.operationGroup = "" + r.pathPattern = "/v2/staking/nominator/{account_id}/pools" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + + } + + case 'p': // Prefix: "pool" + + if l := len("pool"); len(elem) >= l && elem[0:l] == "pool" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + break + } + switch elem[0] { + case '/': // Prefix: "/" + + if l := len("/"); len(elem) >= l && elem[0:l] == "/" { + elem = elem[l:] + } else { + break + } + + // Param: "account_id" + // Match until "/" + idx := strings.IndexByte(elem, '/') + if idx < 0 { + idx = len(elem) + } + args[0] = elem[:idx] + elem = elem[idx:] + + if len(elem) == 0 { + switch method { + case "GET": + r.name = GetStakingPoolInfoOperation + r.summary = "" + r.operationID = "getStakingPoolInfo" + r.operationGroup = "" + r.pathPattern = "/v2/staking/pool/{account_id}" + r.args = args + r.count = 1 + return r, true + default: + return + } + } + switch elem[0] { + case '/': // Prefix: "/history" - } + if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { + elem = elem[l:] + } else { + break + } - } + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetStakingPoolHistoryOperation + r.summary = "" + r.operationID = "getStakingPoolHistory" + r.operationGroup = "" + r.pathPattern = "/v2/staking/pool/{account_id}/history" + r.args = args + r.count = 1 + return r, true + default: + return + } + } - case 'r': // Prefix: "rates" + } - if l := len("rates"); len(elem) >= l && elem[0:l] == "rates" { - elem = elem[l:] - } else { - break - } + case 's': // Prefix: "s" - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetRatesOperation - r.summary = "" - r.operationID = "getRates" - r.operationGroup = "" - r.pathPattern = "/v2/rates" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - switch elem[0] { - case '/': // Prefix: "/" + if l := len("s"); len(elem) >= l && elem[0:l] == "s" { + elem = elem[l:] + } else { + break + } - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetStakingPoolsOperation + r.summary = "" + r.operationID = "getStakingPools" + r.operationGroup = "" + r.pathPattern = "/v2/staking/pools" + r.args = args + r.count = 0 + return r, true + default: + return + } + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'c': // Prefix: "chart" + } - if l := len("chart"); len(elem) >= l && elem[0:l] == "chart" { - elem = elem[l:] - } else { - break - } + } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetChartRatesOperation - r.summary = "" - r.operationID = "getChartRates" - r.operationGroup = "" - r.pathPattern = "/v2/rates/chart" - r.args = args - r.count = 0 - return r, true - default: - return + case 't': // Prefix: "tus" + + if l := len("tus"); len(elem) >= l && elem[0:l] == "tus" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = StatusOperation + r.summary = "" + r.operationID = "status" + r.operationGroup = "" + r.pathPattern = "/v2/status" + r.args = args + r.count = 0 + return r, true + default: + return + } } + } - case 'm': // Prefix: "markets" + case 'o': // Prefix: "orage/providers" - if l := len("markets"); len(elem) >= l && elem[0:l] == "markets" { + if l := len("orage/providers"); len(elem) >= l && elem[0:l] == "orage/providers" { elem = elem[l:] } else { break @@ -7463,11 +7861,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetMarketsRatesOperation + r.name = GetStorageProvidersOperation r.summary = "" - r.operationID = "getMarketsRates" + r.operationID = "getStorageProviders" r.operationGroup = "" - r.pathPattern = "/v2/rates/markets" + r.pathPattern = "/v2/storage/providers" r.args = args r.count = 0 return r, true @@ -7478,23 +7876,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } - } - - case 's': // Prefix: "st" - - if l := len("st"); len(elem) >= l && elem[0:l] == "st" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "a" + case 't': // Prefix: "t" - if l := len("a"); len(elem) >= l && elem[0:l] == "a" { + if l := len("t"); len(elem) >= l && elem[0:l] == "t" { elem = elem[l:] } else { break @@ -7504,9 +7888,9 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'k': // Prefix: "king/" + case 'o': // Prefix: "onconnect/" - if l := len("king/"); len(elem) >= l && elem[0:l] == "king/" { + if l := len("onconnect/"); len(elem) >= l && elem[0:l] == "onconnect/" { elem = elem[l:] } else { break @@ -7516,174 +7900,117 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { break } switch elem[0] { - case 'n': // Prefix: "nominator/" + case 'p': // Prefix: "payload" - if l := len("nominator/"); len(elem) >= l && elem[0:l] == "nominator/" { + if l := len("payload"); len(elem) >= l && elem[0:l] == "payload" { elem = elem[l:] } else { break } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] - if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/pools" - - if l := len("/pools"); len(elem) >= l && elem[0:l] == "/pools" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetAccountNominatorsPoolsOperation - r.summary = "" - r.operationID = "getAccountNominatorsPools" - r.operationGroup = "" - r.pathPattern = "/v2/staking/nominator/{account_id}/pools" - r.args = args - r.count = 1 - return r, true - default: - return - } + // Leaf node. + switch method { + case "GET": + r.name = GetTonConnectPayloadOperation + r.summary = "" + r.operationID = "getTonConnectPayload" + r.operationGroup = "" + r.pathPattern = "/v2/tonconnect/payload" + r.args = args + r.count = 0 + return r, true + default: + return } - } - case 'p': // Prefix: "pool" + case 's': // Prefix: "stateinit" - if l := len("pool"); len(elem) >= l && elem[0:l] == "pool" { + if l := len("stateinit"); len(elem) >= l && elem[0:l] == "stateinit" { elem = elem[l:] } else { break } if len(elem) == 0 { - break - } - switch elem[0] { - case '/': // Prefix: "/" - - if l := len("/"); len(elem) >= l && elem[0:l] == "/" { - elem = elem[l:] - } else { - break - } - - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] - - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetStakingPoolInfoOperation - r.summary = "" - r.operationID = "getStakingPoolInfo" - r.operationGroup = "" - r.pathPattern = "/v2/staking/pool/{account_id}" - r.args = args - r.count = 1 - return r, true - default: - return - } + // Leaf node. + switch method { + case "POST": + r.name = GetAccountInfoByStateInitOperation + r.summary = "" + r.operationID = "getAccountInfoByStateInit" + r.operationGroup = "" + r.pathPattern = "/v2/tonconnect/stateinit" + r.args = args + r.count = 0 + return r, true + default: + return } - switch elem[0] { - case '/': // Prefix: "/history" - - if l := len("/history"); len(elem) >= l && elem[0:l] == "/history" { - elem = elem[l:] - } else { - break - } + } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetStakingPoolHistoryOperation - r.summary = "" - r.operationID = "getStakingPoolHistory" - r.operationGroup = "" - r.pathPattern = "/v2/staking/pool/{account_id}/history" - r.args = args - r.count = 1 - return r, true - default: - return - } - } + } - } + case 'r': // Prefix: "races/" - case 's': // Prefix: "s" + if l := len("races/"); len(elem) >= l && elem[0:l] == "races/" { + elem = elem[l:] + } else { + break + } - if l := len("s"); len(elem) >= l && elem[0:l] == "s" { - elem = elem[l:] - } else { - break - } + if len(elem) == 0 { + break + } + switch elem[0] { + case 'e': // Prefix: "emulate" + origElem := elem + if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetStakingPoolsOperation - r.summary = "" - r.operationID = "getStakingPools" - r.operationGroup = "" - r.pathPattern = "/v2/staking/pools" - r.args = args - r.count = 0 - return r, true - default: - return - } + if len(elem) == 0 { + // Leaf node. + switch method { + case "POST": + r.name = EmulateMessageToTraceOperation + r.summary = "" + r.operationID = "emulateMessageToTrace" + r.operationGroup = "" + r.pathPattern = "/v2/traces/emulate" + r.args = args + r.count = 0 + return r, true + default: + return } - } + elem = origElem } - - case 't': // Prefix: "tus" - - if l := len("tus"); len(elem) >= l && elem[0:l] == "tus" { - elem = elem[l:] - } else { + // Param: "trace_id" + // Leaf parameter, slashes are prohibited + idx := strings.IndexByte(elem, '/') + if idx >= 0 { break } + args[0] = elem + elem = "" if len(elem) == 0 { // Leaf node. switch method { case "GET": - r.name = StatusOperation + r.name = GetTraceOperation r.summary = "" - r.operationID = "status" + r.operationID = "getTrace" r.operationGroup = "" - r.pathPattern = "/v2/status" + r.pathPattern = "/v2/traces/{trace_id}" r.args = args - r.count = 0 + r.count = 1 return r, true default: return @@ -7692,60 +8019,85 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } - case 'o': // Prefix: "orage/providers" + case 'v': // Prefix: "validation/" - if l := len("orage/providers"); len(elem) >= l && elem[0:l] == "orage/providers" { + if l := len("validation/"); len(elem) >= l && elem[0:l] == "validation/" { elem = elem[l:] } else { break } if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetStorageProvidersOperation - r.summary = "" - r.operationID = "getStorageProviders" - r.operationGroup = "" - r.pathPattern = "/v2/storage/providers" - r.args = args - r.count = 0 - return r, true - default: - return - } + break } + switch elem[0] { + case 'r': // Prefix: "r" - } + if l := len("r"); len(elem) >= l && elem[0:l] == "r" { + elem = elem[l:] + } else { + break + } - case 't': // Prefix: "t" + if len(elem) == 0 { + break + } + switch elem[0] { + case 'e': // Prefix: "ewards" - if l := len("t"); len(elem) >= l && elem[0:l] == "t" { - elem = elem[l:] - } else { - break - } + if l := len("ewards"); len(elem) >= l && elem[0:l] == "ewards" { + elem = elem[l:] + } else { + break + } - if len(elem) == 0 { - break - } - switch elem[0] { - case 'o': // Prefix: "onconnect/" + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetRoundRewardsOperation + r.summary = "Get per-validator reward distribution for a finished round" + r.operationID = "getRoundRewards" + r.operationGroup = "" + r.pathPattern = "/v2/validation/rewards" + r.args = args + r.count = 0 + return r, true + default: + return + } + } - if l := len("onconnect/"); len(elem) >= l && elem[0:l] == "onconnect/" { - elem = elem[l:] - } else { - break - } + case 'o': // Prefix: "ounds" - if len(elem) == 0 { - break - } - switch elem[0] { - case 'p': // Prefix: "payload" + if l := len("ounds"); len(elem) >= l && elem[0:l] == "ounds" { + elem = elem[l:] + } else { + break + } + + if len(elem) == 0 { + // Leaf node. + switch method { + case "GET": + r.name = GetValidationRoundsOperation + r.summary = "Get validation round metadata" + r.operationID = "getValidationRounds" + r.operationGroup = "" + r.pathPattern = "/v2/validation/rounds" + r.args = args + r.count = 0 + return r, true + default: + return + } + } + + } - if l := len("payload"); len(elem) >= l && elem[0:l] == "payload" { + case 'v': // Prefix: "validators" + + if l := len("validators"); len(elem) >= l && elem[0:l] == "validators" { elem = elem[l:] } else { break @@ -7755,11 +8107,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetTonConnectPayloadOperation - r.summary = "" - r.operationID = "getTonConnectPayload" + r.name = GetValidatorsOperation + r.summary = "Get all current validators" + r.operationID = "getValidators" r.operationGroup = "" - r.pathPattern = "/v2/tonconnect/payload" + r.pathPattern = "/v2/validation/validators" r.args = args r.count = 0 return r, true @@ -7768,9 +8120,23 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } - case 's': // Prefix: "stateinit" + } + + case 'w': // Prefix: "wallet/" + + if l := len("wallet/"); len(elem) >= l && elem[0:l] == "wallet/" { + elem = elem[l:] + } else { + break + } - if l := len("stateinit"); len(elem) >= l && elem[0:l] == "stateinit" { + if len(elem) == 0 { + break + } + switch elem[0] { + case 'a': // Prefix: "auth/proof" + origElem := elem + if l := len("auth/proof"); len(elem) >= l && elem[0:l] == "auth/proof" { elem = elem[l:] } else { break @@ -7780,11 +8146,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "POST": - r.name = GetAccountInfoByStateInitOperation + r.name = TonConnectProofOperation r.summary = "" - r.operationID = "getAccountInfoByStateInit" + r.operationID = "tonConnectProof" r.operationGroup = "" - r.pathPattern = "/v2/tonconnect/stateinit" + r.pathPattern = "/v2/wallet/auth/proof" r.args = args r.count = 0 return r, true @@ -7793,20 +8159,7 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } } - } - - case 'r': // Prefix: "races/" - - if l := len("races/"); len(elem) >= l && elem[0:l] == "races/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { + elem = origElem case 'e': // Prefix: "emulate" origElem := elem if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { @@ -7819,11 +8172,11 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "POST": - r.name = EmulateMessageToTraceOperation + r.name = EmulateMessageToWalletOperation r.summary = "" - r.operationID = "emulateMessageToTrace" + r.operationID = "emulateMessageToWallet" r.operationGroup = "" - r.pathPattern = "/v2/traces/emulate" + r.pathPattern = "/v2/wallet/emulate" r.args = args r.count = 0 return r, true @@ -7834,24 +8187,23 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { elem = origElem } - // Param: "trace_id" - // Leaf parameter, slashes are prohibited + // Param: "account_id" + // Match until "/" idx := strings.IndexByte(elem, '/') - if idx >= 0 { - break + if idx < 0 { + idx = len(elem) } - args[0] = elem - elem = "" + args[0] = elem[:idx] + elem = elem[idx:] if len(elem) == 0 { - // Leaf node. switch method { case "GET": - r.name = GetTraceOperation + r.name = GetWalletInfoOperation r.summary = "" - r.operationID = "getTrace" + r.operationID = "getWalletInfo" r.operationGroup = "" - r.pathPattern = "/v2/traces/{trace_id}" + r.pathPattern = "/v2/wallet/{account_id}" r.args = args r.count = 1 return r, true @@ -7859,61 +8211,10 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { return } } - - } - - case 'v': // Prefix: "validation/" - - if l := len("validation/"); len(elem) >= l && elem[0:l] == "validation/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'r': // Prefix: "r" - - if l := len("r"); len(elem) >= l && elem[0:l] == "r" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } switch elem[0] { - case 'e': // Prefix: "ewards" - - if l := len("ewards"); len(elem) >= l && elem[0:l] == "ewards" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetRoundRewardsOperation - r.summary = "Get per-validator reward distribution for a finished round" - r.operationID = "getRoundRewards" - r.operationGroup = "" - r.pathPattern = "/v2/validation/rewards" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - - case 'o': // Prefix: "ounds" + case '/': // Prefix: "/seqno" - if l := len("ounds"); len(elem) >= l && elem[0:l] == "ounds" { + if l := len("/seqno"); len(elem) >= l && elem[0:l] == "/seqno" { elem = elem[l:] } else { break @@ -7923,13 +8224,13 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { // Leaf node. switch method { case "GET": - r.name = GetValidationRoundsOperation - r.summary = "Get validation round metadata" - r.operationID = "getValidationRounds" + r.name = GetAccountSeqnoOperation + r.summary = "" + r.operationID = "getAccountSeqno" r.operationGroup = "" - r.pathPattern = "/v2/validation/rounds" + r.pathPattern = "/v2/wallet/{account_id}/seqno" r.args = args - r.count = 0 + r.count = 1 return r, true default: return @@ -7938,148 +8239,6 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) { } - case 'v': // Prefix: "validators" - - if l := len("validators"); len(elem) >= l && elem[0:l] == "validators" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetValidatorsOperation - r.summary = "Get all current validators" - r.operationID = "getValidators" - r.operationGroup = "" - r.pathPattern = "/v2/validation/validators" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - - } - - case 'w': // Prefix: "wallet/" - - if l := len("wallet/"); len(elem) >= l && elem[0:l] == "wallet/" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - break - } - switch elem[0] { - case 'a': // Prefix: "auth/proof" - origElem := elem - if l := len("auth/proof"); len(elem) >= l && elem[0:l] == "auth/proof" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "POST": - r.name = TonConnectProofOperation - r.summary = "" - r.operationID = "tonConnectProof" - r.operationGroup = "" - r.pathPattern = "/v2/wallet/auth/proof" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - - elem = origElem - case 'e': // Prefix: "emulate" - origElem := elem - if l := len("emulate"); len(elem) >= l && elem[0:l] == "emulate" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "POST": - r.name = EmulateMessageToWalletOperation - r.summary = "" - r.operationID = "emulateMessageToWallet" - r.operationGroup = "" - r.pathPattern = "/v2/wallet/emulate" - r.args = args - r.count = 0 - return r, true - default: - return - } - } - - elem = origElem - } - // Param: "account_id" - // Match until "/" - idx := strings.IndexByte(elem, '/') - if idx < 0 { - idx = len(elem) - } - args[0] = elem[:idx] - elem = elem[idx:] - - if len(elem) == 0 { - switch method { - case "GET": - r.name = GetWalletInfoOperation - r.summary = "" - r.operationID = "getWalletInfo" - r.operationGroup = "" - r.pathPattern = "/v2/wallet/{account_id}" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - switch elem[0] { - case '/': // Prefix: "/seqno" - - if l := len("/seqno"); len(elem) >= l && elem[0:l] == "/seqno" { - elem = elem[l:] - } else { - break - } - - if len(elem) == 0 { - // Leaf node. - switch method { - case "GET": - r.name = GetAccountSeqnoOperation - r.summary = "" - r.operationID = "getAccountSeqno" - r.operationGroup = "" - r.pathPattern = "/v2/wallet/{account_id}/seqno" - r.args = args - r.count = 1 - return r, true - default: - return - } - } - } } diff --git a/pkg/oas/oas_schemas_gen.go b/pkg/oas/oas_schemas_gen.go index cae4b872..055de38e 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,52 @@ 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 +} + // NewOptPrice returns new OptPrice with value set to v. func NewOptPrice(v Price) OptPrice { return OptPrice{ @@ -16811,6 +17028,55 @@ 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 +} + // 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 37d9317b..f0c2d0bb 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 /cocoon/workers + GetCocoonWorkers(ctx context.Context) (GetCocoonWorkersRes, error) // GetDnsInfo implements getDnsInfo operation. // // Get full information about domain name. @@ -668,6 +674,12 @@ 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 /cocoon/query + PostCocoonQuery(ctx context.Context, req jx.Raw, params PostCocoonQueryParams) (PostCocoonQueryRes, 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 a46bd681..ef4901e7 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 /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,15 @@ 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 /cocoon/query +func (UnimplementedHandler) PostCocoonQuery(ctx context.Context, req jx.Raw, params PostCocoonQueryParams) (r PostCocoonQueryRes, _ 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