From ee407652d79da77dc4174dde7c7d60760560b034 Mon Sep 17 00:00:00 2001 From: Mike Purvis Date: Sat, 18 Apr 2026 13:29:06 -0700 Subject: [PATCH 1/3] Add agent discoverability surfaces --- package.json | 1 + scripts/audit-agent-readiness-live.js | 160 ++ scripts/audit-indexing-surface.js | 509 +++++- scripts/generate-ai-surfaces.js | 233 ++- src/data/openapiSnapshots/fastnear.json | 1324 ++++++++++++++ src/data/openapiSnapshots/neardata.json | 1536 +++++++++++++++++ static/.well-known/agent-skills/auth/SKILL.md | 99 ++ static/.well-known/agent-skills/index.json | 33 + .../agent-skills/overview/SKILL.md | 141 ++ .../agent-skills/playbooks/SKILL.md | 264 +++ .../agent-skills/surface-routing/SKILL.md | 259 +++ static/.well-known/api-catalog | 67 + static/_headers | 117 ++ static/_worker.js | 219 +++ static/openapi/fastnear.json | 1324 ++++++++++++++ static/openapi/neardata.json | 1536 +++++++++++++++++ static/robots.txt | 1 + static/ru/agents.md | 2 - static/ru/agents/choosing-surfaces.md | 2 - static/ru/agents/choosing-surfaces/index.md | 2 - static/ru/agents/index.md | 2 - static/ru/agents/playbooks.md | 2 - static/ru/agents/playbooks/index.md | 2 - static/ru/llms-full.txt | 6 - static/ru/structured-data/site-graph.json | 980 +++++------ 25 files changed, 8296 insertions(+), 525 deletions(-) create mode 100644 scripts/audit-agent-readiness-live.js create mode 100644 src/data/openapiSnapshots/fastnear.json create mode 100644 src/data/openapiSnapshots/neardata.json create mode 100644 static/.well-known/agent-skills/auth/SKILL.md create mode 100644 static/.well-known/agent-skills/index.json create mode 100644 static/.well-known/agent-skills/overview/SKILL.md create mode 100644 static/.well-known/agent-skills/playbooks/SKILL.md create mode 100644 static/.well-known/agent-skills/surface-routing/SKILL.md create mode 100644 static/.well-known/api-catalog create mode 100644 static/_headers create mode 100644 static/_worker.js create mode 100644 static/openapi/fastnear.json create mode 100644 static/openapi/neardata.json diff --git a/package.json b/package.json index 66f6136..b398add 100644 --- a/package.json +++ b/package.json @@ -27,6 +27,7 @@ "audit:i18n:ru": "node scripts/audit-ru-translation.js", "audit:ru-terminology": "node scripts/audit-ru-terminology.js", "audit:indexing": "yarn test:route-semantics && yarn audit:page-models && yarn build && node scripts/audit-indexing-surface.js", + "audit:agent-readiness:live": "node scripts/audit-agent-readiness-live.js", "audit:algolia-highlights": "node scripts/audit-algolia-highlights.js", "audit:algolia-relevance": "node scripts/audit-algolia-relevance.js", "algolia:inspect": "node scripts/algolia-inspect.js", diff --git a/scripts/audit-agent-readiness-live.js b/scripts/audit-agent-readiness-live.js new file mode 100644 index 0000000..b5aceb4 --- /dev/null +++ b/scripts/audit-agent-readiness-live.js @@ -0,0 +1,160 @@ +#!/usr/bin/env node + +const SITE_ORIGIN = (process.env.SITE_ORIGIN || "https://docs.fastnear.com").replace(/\/+$/, ""); + +const API_CATALOG_FRAGMENT = 'rel="api-catalog"'; +const AGENT_SKILLS_FRAGMENT = '<' + '/.well-known/agent-skills/index.json' + '>'; +const ROOT_SITE_GRAPH_FRAGMENT = ''; +const RU_SITE_GRAPH_FRAGMENT = ''; +const RPC_SERVICE_DESC_FRAGMENT = ''; +const FASTNEAR_SERVICE_DESC_FRAGMENT = ''; +const NEARDATA_SERVICE_DESC_FRAGMENT = ''; +const MARKDOWN_ALTERNATE_FRAGMENT = + '; rel="alternate"; type="text/markdown"'; + +function assert(condition, message) { + if (!condition) { + throw new Error(message); + } +} + +async function fetchText(url, init) { + const response = await fetch(url, init); + const text = await response.text(); + return { response, text }; +} + +async function assertHeadDiscoveryHeaders(pathname, expectedFragments) { + const response = await fetch(`${SITE_ORIGIN}${pathname}`, { method: "HEAD" }); + assert(response.ok, `HEAD ${pathname} failed with ${response.status}`); + + const link = response.headers.get("link") || ""; + expectedFragments.forEach((fragment) => { + assert(link.includes(fragment), `HEAD ${pathname} is missing ${fragment}`); + }); +} + +async function main() { + const discoveryChecks = [ + { + pathname: "/", + expectedFragments: [API_CATALOG_FRAGMENT, 'rel="service-doc"', AGENT_SKILLS_FRAGMENT, ROOT_SITE_GRAPH_FRAGMENT], + }, + { + pathname: "/ru", + expectedFragments: [API_CATALOG_FRAGMENT, 'rel="service-doc"', AGENT_SKILLS_FRAGMENT, RU_SITE_GRAPH_FRAGMENT], + }, + { + pathname: "/rpc", + expectedFragments: [API_CATALOG_FRAGMENT, 'rel="service-desc"', RPC_SERVICE_DESC_FRAGMENT, ROOT_SITE_GRAPH_FRAGMENT], + }, + { + pathname: "/ru/rpc", + expectedFragments: [API_CATALOG_FRAGMENT, 'rel="service-desc"', RPC_SERVICE_DESC_FRAGMENT, RU_SITE_GRAPH_FRAGMENT], + }, + { + pathname: "/api", + expectedFragments: [API_CATALOG_FRAGMENT, 'rel="service-desc"', FASTNEAR_SERVICE_DESC_FRAGMENT, ROOT_SITE_GRAPH_FRAGMENT], + }, + { + pathname: "/ru/api", + expectedFragments: [API_CATALOG_FRAGMENT, 'rel="service-desc"', FASTNEAR_SERVICE_DESC_FRAGMENT, RU_SITE_GRAPH_FRAGMENT], + }, + { + pathname: "/neardata", + expectedFragments: [API_CATALOG_FRAGMENT, 'rel="service-desc"', NEARDATA_SERVICE_DESC_FRAGMENT, ROOT_SITE_GRAPH_FRAGMENT], + }, + { + pathname: "/ru/neardata", + expectedFragments: [API_CATALOG_FRAGMENT, 'rel="service-desc"', NEARDATA_SERVICE_DESC_FRAGMENT, RU_SITE_GRAPH_FRAGMENT], + }, + { + pathname: "/agents", + expectedFragments: [API_CATALOG_FRAGMENT, AGENT_SKILLS_FRAGMENT, ROOT_SITE_GRAPH_FRAGMENT], + }, + { + pathname: "/ru/agents", + expectedFragments: [API_CATALOG_FRAGMENT, AGENT_SKILLS_FRAGMENT, RU_SITE_GRAPH_FRAGMENT], + }, + { + pathname: "/auth", + expectedFragments: [API_CATALOG_FRAGMENT, ROOT_SITE_GRAPH_FRAGMENT], + }, + { + pathname: "/ru/auth", + expectedFragments: [API_CATALOG_FRAGMENT, RU_SITE_GRAPH_FRAGMENT], + }, + ]; + + for (const { pathname, expectedFragments } of discoveryChecks) { + await assertHeadDiscoveryHeaders(pathname, expectedFragments); + } + + const apiCatalog = await fetch(`${SITE_ORIGIN}/.well-known/api-catalog`); + assert(apiCatalog.ok, `GET /.well-known/api-catalog failed with ${apiCatalog.status}`); + const apiCatalogType = apiCatalog.headers.get("content-type") || ""; + assert( + apiCatalogType.includes("application/linkset+json"), + "API catalog must return application/linkset+json" + ); + const apiCatalogJson = await apiCatalog.json(); + assert(Array.isArray(apiCatalogJson.linkset), "API catalog must expose a linkset array"); + + const indexResponse = await fetch(`${SITE_ORIGIN}/.well-known/agent-skills/index.json`); + assert( + indexResponse.ok, + `GET /.well-known/agent-skills/index.json failed with ${indexResponse.status}` + ); + const indexType = indexResponse.headers.get("content-type") || ""; + assert(indexType.includes("application/json"), "Agent Skills index must return JSON"); + const indexJson = await indexResponse.json(); + assert(Array.isArray(indexJson.skills), "Agent Skills index must expose a skills array"); + + for (const skill of indexJson.skills) { + const skillResponse = await fetch(new URL(skill.url, `${SITE_ORIGIN}/`)); + assert(skillResponse.ok, `GET ${skill.url} failed with ${skillResponse.status}`); + const skillType = skillResponse.headers.get("content-type") || ""; + assert( + skillType.includes("text/markdown"), + `Skill ${skill.name} must return text/markdown` + ); + } + + const { response: markdownResponse, text: markdownText } = await fetchText( + `${SITE_ORIGIN}/rpc/account/view-account`, + { + headers: { + Accept: "text/markdown", + }, + } + ); + assert( + markdownResponse.ok, + `GET /rpc/account/view-account as markdown failed with ${markdownResponse.status}` + ); + const markdownType = markdownResponse.headers.get("content-type") || ""; + assert( + markdownType.includes("text/markdown"), + "GET /rpc/account/view-account with Accept: text/markdown must return markdown" + ); + assert( + !/ { + console.error(`Live agent-discoverability smoke checks failed: ${error.message}`); + process.exitCode = 1; +}); diff --git a/scripts/audit-indexing-surface.js b/scripts/audit-indexing-surface.js index 9ec480e..f7ef0a9 100644 --- a/scripts/audit-indexing-surface.js +++ b/scripts/audit-indexing-surface.js @@ -1,5 +1,6 @@ #!/usr/bin/env node +const crypto = require("node:crypto"); const fs = require("node:fs"); const path = require("node:path"); const { @@ -41,13 +42,213 @@ const ALGOLIA_RELEVANCE_AUDIT_PATH = path.join(ROOT, "scripts/audit-algolia-rele const SEARCH_BAR_PATH = path.join(ROOT, "src/theme/SearchBar/index.js"); const SEARCH_BAR_RUNTIME_PATH = path.join(ROOT, "src/theme/SearchBar/AlgoliaSearchRuntime.js"); const SEARCH_BAR_STYLES_PATH = path.join(ROOT, "src/theme/SearchBar/styles.css"); +const HEADERS_PATH = path.join(BUILD_ROOT, "_headers"); const REDIRECTS_PATH = path.join(BUILD_ROOT, "_redirects"); const ROBOTS_PATH = path.join(BUILD_ROOT, "robots.txt"); +const API_CATALOG_PATH = path.join(BUILD_ROOT, ".well-known", "api-catalog"); +const AGENT_SKILLS_INDEX_PATH = path.join( + BUILD_ROOT, + ".well-known", + "agent-skills", + "index.json" +); +const WORKER_SOURCE_PATH = path.join(ROOT, "static", "_worker.js"); const PAGE_MODELS_PATH = path.join(ROOT, "src/data/generatedFastnearPageModels.json"); const STRUCTURED_GRAPH_PATH = path.join(ROOT, "src/data/generatedFastnearStructuredGraph.json"); const PRODUCTION_SITE_URL = "https://docs.fastnear.com"; const WEBSITE_ID = `${PRODUCTION_SITE_URL}/#website`; const ORGANIZATION_ID = `${PRODUCTION_SITE_URL}/#organization`; +const EXPECTED_CONTENT_SIGNAL = "Content-Signal: search=yes, ai-input=yes, ai-train=yes"; +const API_CATALOG_LINK_HEADER = + 'Link: ; rel="api-catalog"; type="application/linkset+json"'; +const AGENT_SKILLS_LINK_HEADER = + 'Link: ; rel="service-meta"; type="application/json"'; +const ROOT_SITE_GRAPH_LINK_HEADER = + 'Link: ; rel="service-meta"; type="application/json"'; +const RU_SITE_GRAPH_LINK_HEADER = + 'Link: ; rel="service-meta"; type="application/json"'; +const ROOT_SERVICE_DOC_LINK_HEADER = 'Link: ; rel="service-doc"; type="text/html"'; +const RU_SERVICE_DOC_LINK_HEADER = 'Link: ; rel="service-doc"; type="text/html"'; +const RPC_SERVICE_DESC_LINK_HEADER = + 'Link: ; rel="service-desc"; type="application/json"'; +const FASTNEAR_SERVICE_DESC_LINK_HEADER = + 'Link: ; rel="service-desc"; type="application/json"'; +const NEARDATA_SERVICE_DESC_LINK_HEADER = + 'Link: ; rel="service-desc"; type="application/json"'; +const EXPECTED_ROOT_LINK_HEADERS = [ + API_CATALOG_LINK_HEADER, + ROOT_SERVICE_DOC_LINK_HEADER, + AGENT_SKILLS_LINK_HEADER, + ROOT_SITE_GRAPH_LINK_HEADER, +]; +const EXPECTED_RU_LINK_HEADERS = [ + API_CATALOG_LINK_HEADER, + RU_SERVICE_DOC_LINK_HEADER, + AGENT_SKILLS_LINK_HEADER, + RU_SITE_GRAPH_LINK_HEADER, +]; +const EXPECTED_RPC_LINK_HEADERS = [ + API_CATALOG_LINK_HEADER, + RPC_SERVICE_DESC_LINK_HEADER, + ROOT_SITE_GRAPH_LINK_HEADER, +]; +const EXPECTED_RU_RPC_LINK_HEADERS = [ + API_CATALOG_LINK_HEADER, + RPC_SERVICE_DESC_LINK_HEADER, + RU_SITE_GRAPH_LINK_HEADER, +]; +const EXPECTED_API_LINK_HEADERS = [ + API_CATALOG_LINK_HEADER, + FASTNEAR_SERVICE_DESC_LINK_HEADER, + ROOT_SITE_GRAPH_LINK_HEADER, +]; +const EXPECTED_RU_API_LINK_HEADERS = [ + API_CATALOG_LINK_HEADER, + FASTNEAR_SERVICE_DESC_LINK_HEADER, + RU_SITE_GRAPH_LINK_HEADER, +]; +const EXPECTED_NEARDATA_LINK_HEADERS = [ + API_CATALOG_LINK_HEADER, + NEARDATA_SERVICE_DESC_LINK_HEADER, + ROOT_SITE_GRAPH_LINK_HEADER, +]; +const EXPECTED_RU_NEARDATA_LINK_HEADERS = [ + API_CATALOG_LINK_HEADER, + NEARDATA_SERVICE_DESC_LINK_HEADER, + RU_SITE_GRAPH_LINK_HEADER, +]; +const EXPECTED_AGENTS_LINK_HEADERS = [ + API_CATALOG_LINK_HEADER, + AGENT_SKILLS_LINK_HEADER, + ROOT_SITE_GRAPH_LINK_HEADER, +]; +const EXPECTED_RU_AGENTS_LINK_HEADERS = [ + API_CATALOG_LINK_HEADER, + AGENT_SKILLS_LINK_HEADER, + RU_SITE_GRAPH_LINK_HEADER, +]; +const EXPECTED_AUTH_LINK_HEADERS = [ + API_CATALOG_LINK_HEADER, + ROOT_SITE_GRAPH_LINK_HEADER, +]; +const EXPECTED_RU_AUTH_LINK_HEADERS = [ + API_CATALOG_LINK_HEADER, + RU_SITE_GRAPH_LINK_HEADER, +]; +const EXPECTED_DISCOVERY_HEADER_RULES = [ + { + path: "/", + lines: EXPECTED_ROOT_LINK_HEADERS, + }, + { + path: "/ru", + lines: EXPECTED_RU_LINK_HEADERS, + }, + { + path: "/rpc", + lines: EXPECTED_RPC_LINK_HEADERS, + }, + { + path: "/rpc/*", + lines: EXPECTED_RPC_LINK_HEADERS, + }, + { + path: "/ru/rpc", + lines: EXPECTED_RU_RPC_LINK_HEADERS, + }, + { + path: "/ru/rpc/*", + lines: EXPECTED_RU_RPC_LINK_HEADERS, + }, + { + path: "/api", + lines: EXPECTED_API_LINK_HEADERS, + }, + { + path: "/api/*", + lines: EXPECTED_API_LINK_HEADERS, + }, + { + path: "/ru/api", + lines: EXPECTED_RU_API_LINK_HEADERS, + }, + { + path: "/ru/api/*", + lines: EXPECTED_RU_API_LINK_HEADERS, + }, + { + path: "/neardata", + lines: EXPECTED_NEARDATA_LINK_HEADERS, + }, + { + path: "/neardata/*", + lines: EXPECTED_NEARDATA_LINK_HEADERS, + }, + { + path: "/ru/neardata", + lines: EXPECTED_RU_NEARDATA_LINK_HEADERS, + }, + { + path: "/ru/neardata/*", + lines: EXPECTED_RU_NEARDATA_LINK_HEADERS, + }, + { + path: "/agents", + lines: EXPECTED_AGENTS_LINK_HEADERS, + }, + { + path: "/agents/*", + lines: EXPECTED_AGENTS_LINK_HEADERS, + }, + { + path: "/ru/agents", + lines: EXPECTED_RU_AGENTS_LINK_HEADERS, + }, + { + path: "/ru/agents/*", + lines: EXPECTED_RU_AGENTS_LINK_HEADERS, + }, + { + path: "/auth", + lines: EXPECTED_AUTH_LINK_HEADERS, + }, + { + path: "/auth/*", + lines: EXPECTED_AUTH_LINK_HEADERS, + }, + { + path: "/ru/auth", + lines: EXPECTED_RU_AUTH_LINK_HEADERS, + }, + { + path: "/ru/auth/*", + lines: EXPECTED_RU_AUTH_LINK_HEADERS, + }, +]; +const EXPECTED_HEADER_RULES = [ + ...EXPECTED_DISCOVERY_HEADER_RULES, + { + path: "/.well-known/api-catalog", + lines: [ + 'Content-Type: application/linkset+json; charset=utf-8; profile="https://www.rfc-editor.org/info/rfc9727"', + API_CATALOG_LINK_HEADER, + ], + }, + { + path: "/.well-known/agent-skills/index.json", + lines: ['Content-Type: application/json; charset=utf-8'], + }, + { + path: "/.well-known/agent-skills/*/SKILL.md", + lines: ['Content-Type: text/markdown; charset=utf-8'], + }, +]; +const EXPECTED_API_CATALOG_ANCHORS = [ + "https://api.fastnear.com", + "https://mainnet.neardata.xyz", + "https://rpc.mainnet.fastnear.com", +]; +const EXPECTED_AGENT_SKILLS = ["auth", "overview", "playbooks", "surface-routing"]; const hideEarlyApiFamilies = /^(1|true|yes|on)$/i.test( process.env.HIDE_EARLY_API_FAMILIES || "" @@ -117,6 +318,10 @@ function loadJson(filePath, label) { return JSON.parse(fs.readFileSync(filePath, "utf8")); } +function sha256File(filePath) { + return `sha256:${crypto.createHash("sha256").update(fs.readFileSync(filePath)).digest("hex")}`; +} + function walkDocs(dirPath) { const collected = []; @@ -195,6 +400,18 @@ function buildCrawlerUrl(route, locale = DEFAULT_LOCALE) { return `${PRODUCTION_SITE_URL}${localizeRoute(route, locale)}`; } +function buildSiteGraphDocumentUrl(locale = DEFAULT_LOCALE) { + return buildLocalizedProductionUrl("/structured-data/site-graph.json", locale); +} + +function buildExpectedSiteGraphFamilyEntityId(familyId, locale = DEFAULT_LOCALE) { + return `${buildSiteGraphDocumentUrl(locale)}#family-${familyId}`; +} + +function buildExpectedSiteGraphOperationEntityId(pageModelId, locale = DEFAULT_LOCALE) { + return `${buildSiteGraphDocumentUrl(locale)}#operation-${pageModelId}`; +} + function getSiteGraphPath(locale = DEFAULT_LOCALE) { return path.join(BUILD_ROOT, localizeRoute("/structured-data/site-graph.json", locale)); } @@ -284,6 +501,10 @@ function buildMetaPattern(name, value) { ); } +function stripHeaderName(line) { + return String(line || "").replace(/^[^:]+:\s*/, ""); +} + function parseJsonLdScripts(html, label) { return [...html.matchAll(/([\s\S]*?)<\/script>/g)] .map((match, index) => { @@ -707,6 +928,256 @@ function parseSitemapUrls(locale = DEFAULT_LOCALE) { ); } +function auditAgentDiscoveryArtifacts() { + assert(fs.existsSync(HEADERS_PATH), `Missing _headers: ${path.relative(ROOT, HEADERS_PATH)}`); + const headersText = fs.readFileSync(HEADERS_PATH, "utf8"); + EXPECTED_HEADER_RULES.forEach(({ path: rulePath, lines }) => { + assert(headersText.includes(`${rulePath}\n`), `_headers is missing the ${rulePath} rule`); + lines.forEach((line) => { + assert( + headersText.includes(line), + `_headers is missing "${line}" for ${rulePath}` + ); + }); + }); + + assert( + fs.existsSync(API_CATALOG_PATH), + `Missing API catalog: ${path.relative(ROOT, API_CATALOG_PATH)}` + ); + const apiCatalog = loadJson(API_CATALOG_PATH, "API catalog"); + assert(Array.isArray(apiCatalog.linkset), "API catalog must expose a linkset array"); + const apiCatalogAnchors = apiCatalog.linkset.map((entry) => entry.anchor).sort(); + assert( + JSON.stringify(apiCatalogAnchors) === JSON.stringify(EXPECTED_API_CATALOG_ANCHORS), + `API catalog anchors are out of sync. Expected ${EXPECTED_API_CATALOG_ANCHORS.join(", ")}, got ${apiCatalogAnchors.join(", ")}` + ); + apiCatalog.linkset.forEach((entry) => { + ["service-desc", "service-doc", "status"].forEach((relation) => { + assert( + Array.isArray(entry[relation]) && entry[relation].length > 0, + `API catalog entry ${entry.anchor} must include ${relation}` + ); + entry[relation].forEach((target) => { + assert( + typeof target.href === "string" && /^https:\/\//.test(target.href), + `API catalog entry ${entry.anchor} has an invalid ${relation} target` + ); + }); + }); + }); + [ + "/openapi/fastnear.json", + "/openapi/neardata.json", + ].forEach((route) => { + const filePath = routeToBuildAssetPath(route); + assert( + fs.existsSync(filePath), + `Build is missing the vendored OpenAPI snapshot ${route}` + ); + }); + + assert( + fs.existsSync(AGENT_SKILLS_INDEX_PATH), + `Missing Agent Skills index: ${path.relative(ROOT, AGENT_SKILLS_INDEX_PATH)}` + ); + const agentSkillsIndex = loadJson(AGENT_SKILLS_INDEX_PATH, "Agent Skills index"); + assert( + agentSkillsIndex.$schema === "https://schemas.agentskills.io/discovery/0.2.0/schema.json", + "Agent Skills index must use the v0.2.0 schema URI" + ); + assert(Array.isArray(agentSkillsIndex.skills), "Agent Skills index must expose a skills array"); + const skillNames = agentSkillsIndex.skills.map((skill) => skill.name).sort(); + assert( + JSON.stringify(skillNames) === JSON.stringify(EXPECTED_AGENT_SKILLS), + `Agent Skills index names are out of sync. Expected ${EXPECTED_AGENT_SKILLS.join(", ")}, got ${skillNames.join(", ")}` + ); + agentSkillsIndex.skills.forEach((skill) => { + assert(skill.type === "skill-md", `Agent skill ${skill.name} must use type=skill-md`); + assert( + typeof skill.description === "string" && skill.description.length > 0, + `Agent skill ${skill.name} must include a description` + ); + assert( + typeof skill.url === "string" && skill.url.startsWith("/.well-known/agent-skills/"), + `Agent skill ${skill.name} must use a stable well-known URL` + ); + const filePath = routeToBuildAssetPath(skill.url); + assert( + fs.existsSync(filePath), + `Agent skill artifact is missing: ${path.relative(ROOT, filePath)}` + ); + assert( + skill.digest === sha256File(filePath), + `Agent skill digest mismatch for ${skill.name}` + ); + const content = fs.readFileSync(filePath, "utf8"); + assert( + content.startsWith("---\n"), + `Agent skill ${skill.name} must include YAML frontmatter` + ); + assert( + content.includes(`name: "${skill.name}"`) || content.includes(`name: '${skill.name}'`), + `Agent skill ${skill.name} frontmatter must declare its name` + ); + }); +} + +async function auditMarkdownDiscoveryWorker({ routeEntries, structuredGraph }) { + assert( + fs.existsSync(WORKER_SOURCE_PATH), + `Missing worker source: ${path.relative(ROOT, WORKER_SOURCE_PATH)}` + ); + const workerSource = fs.readFileSync(WORKER_SOURCE_PATH, "utf8"); + const workerModule = await import( + `data:text/javascript;base64,${Buffer.from(workerSource, "utf8").toString("base64")}` + ); + const workerFetch = workerModule?.default?.fetch; + assert(typeof workerFetch === "function", "static/_worker.js must export a default fetch handler"); + + const env = { + ASSETS: { + async fetch(request) { + const url = new URL(request.url); + const headers = new Headers(); + + if (url.pathname.endsWith(".md")) { + headers.set("Content-Type", "text/markdown; charset=utf-8"); + return new Response(`# ${url.pathname}\n`, { + headers, + status: 200, + }); + } + + headers.set("Content-Type", "text/html; charset=utf-8"); + return new Response(`${url.pathname}`, { + headers, + status: 200, + }); + }, + }, + }; + + const visibleOperations = structuredGraph.operations.filter( + (operation) => !isHiddenCanonicalRoute(operation.canonicalPath) + ); + const localizedRoutes = [ + ...routeEntries.map((entry) => entry.route), + ...visibleOperations.map((operation) => operation.canonicalPath), + ]; + + for (const locale of SUPPORTED_LOCALES) { + for (const route of localizedRoutes) { + const localizedRoute = localizeRoute(route, locale); + const response = await workerFetch(new Request(buildLocalizedProductionUrl(route, locale)), env); + const link = response.headers.get("Link") || ""; + assert( + link.includes( + `<${getExpectedMarkdownMirrorPath(localizedRoute)}>; rel="alternate"; type="text/markdown"` + ), + `Worker should advertise markdown alternate for ${localizedRoute}` + ); + assert( + response.headers.get("Vary")?.toLowerCase().includes("accept"), + `Worker should add Vary: Accept for ${localizedRoute}` + ); + } + } + + const discoveryChecks = [ + { + route: "/", + expectedLinks: EXPECTED_ROOT_LINK_HEADERS, + }, + { + route: "/ru", + expectedLinks: EXPECTED_RU_LINK_HEADERS, + }, + { + route: "/rpc/account/view-account", + expectedLinks: EXPECTED_RPC_LINK_HEADERS, + }, + { + route: "/ru/rpc/account/view-account", + expectedLinks: EXPECTED_RU_RPC_LINK_HEADERS, + }, + { + route: "/api/v1/account-full", + expectedLinks: EXPECTED_API_LINK_HEADERS, + }, + { + route: "/ru/api/v1/account-full", + expectedLinks: EXPECTED_RU_API_LINK_HEADERS, + }, + { + route: "/neardata/last-block-final", + expectedLinks: EXPECTED_NEARDATA_LINK_HEADERS, + }, + { + route: "/ru/neardata/last-block-final", + expectedLinks: EXPECTED_RU_NEARDATA_LINK_HEADERS, + }, + { + route: "/agents", + expectedLinks: EXPECTED_AGENTS_LINK_HEADERS, + }, + { + route: "/ru/agents", + expectedLinks: EXPECTED_RU_AGENTS_LINK_HEADERS, + }, + { + route: "/auth", + expectedLinks: EXPECTED_AUTH_LINK_HEADERS, + }, + { + route: "/ru/auth", + expectedLinks: EXPECTED_RU_AUTH_LINK_HEADERS, + }, + ]; + + for (const { route, expectedLinks } of discoveryChecks) { + const htmlResponse = await workerFetch(new Request(`${PRODUCTION_SITE_URL}${route}`), env); + const markdownResponse = await workerFetch( + new Request(`${PRODUCTION_SITE_URL}${route}`, { + headers: { + Accept: "text/markdown", + }, + }), + env + ); + + const htmlLinks = htmlResponse.headers.get("Link") || ""; + const markdownLinks = markdownResponse.headers.get("Link") || ""; + + expectedLinks.forEach((line) => { + const linkValue = stripHeaderName(line); + assert(htmlLinks.includes(linkValue), `Worker should add ${linkValue} to HTML route ${route}`); + assert( + markdownLinks.includes(linkValue), + `Worker should preserve ${linkValue} on markdown route ${route}` + ); + }); + + assert( + markdownResponse.headers.get("Content-Type")?.includes("text/markdown"), + `Worker should return markdown content-type for ${route}` + ); + } + + const headResponse = await workerFetch( + new Request(`${PRODUCTION_SITE_URL}/rpc/account/view-account`, { + method: "HEAD", + }), + env + ); + assert( + (headResponse.headers.get("Link") || "").includes( + '; rel="alternate"; type="text/markdown"' + ), + "Worker should advertise markdown alternate on HEAD responses" + ); +} + function auditDocsBuildOutput(routeEntries, structuredGraph) { const pageModels = loadJson(PAGE_MODELS_PATH, "generated FastNear page models"); const pageModelsById = Object.fromEntries( @@ -732,6 +1203,11 @@ function auditDocsBuildOutput(routeEntries, structuredGraph) { `robots.txt must explicitly allow ${userAgent}` ); }); + assert( + robotsText.includes(EXPECTED_CONTENT_SIGNAL), + "robots.txt must declare the agreed Content-Signal policy" + ); + auditAgentDiscoveryArtifacts(); assert(fs.existsSync(REDIRECTS_PATH), `Missing redirects file: ${path.relative(ROOT, REDIRECTS_PATH)}`); const redirectsText = fs.readFileSync(REDIRECTS_PATH, "utf8"); @@ -1315,12 +1791,17 @@ function auditSiteGraphArtifact({ routeEntries, structuredGraph }) { `Hosted page has wrong markdownMirrorUrl in site-graph.json: ${localizedCanonicalPath}` ); assert( - page.entityIds?.mainEntityId === `${PRODUCTION_SITE_URL}/structured-data/operations/${operation.pageModelId}`, + page.entityIds?.mainEntityId === + buildExpectedSiteGraphOperationEntityId(operation.pageModelId, locale), `Hosted page has wrong mainEntityId in site-graph.json: ${localizedCanonicalPath}` ); }); siteGraph.families.forEach((family) => { + assert( + family["@id"] === buildExpectedSiteGraphFamilyEntityId(family.id, locale), + `site-graph.json family ${family.id} should use an anchored @id in ${locale}` + ); assert( family.providerId === ORGANIZATION_ID, `site-graph.json family ${family.id} should point providerId to the Organization node` @@ -1336,6 +1817,14 @@ function auditSiteGraphArtifact({ routeEntries, structuredGraph }) { }); siteGraph.operations.forEach((operation) => { + assert( + operation["@id"] === buildExpectedSiteGraphOperationEntityId(operation.pageModelId, locale), + `site-graph.json operation ${operation.pageModelId} should use an anchored @id in ${locale}` + ); + assert( + operation.familyEntityId === buildExpectedSiteGraphFamilyEntityId(operation.familyId, locale), + `site-graph.json operation ${operation.pageModelId} should use an anchored familyEntityId` + ); assert( operation.publisherId === ORGANIZATION_ID, `site-graph.json operation ${operation.pageModelId} should point publisherId to the Organization node` @@ -1364,6 +1853,15 @@ function auditSiteGraphArtifact({ routeEntries, structuredGraph }) { ); }); + assert( + !JSON.stringify(siteGraph).includes('"/structured-data/families/'), + `site-graph.json should not reference nonexistent /structured-data/families URLs for ${locale}` + ); + assert( + !JSON.stringify(siteGraph).includes('"/structured-data/operations/'), + `site-graph.json should not reference nonexistent /structured-data/operations URLs for ${locale}` + ); + assert( siteGraph.discovery?.llmsIndexUrl === buildLocalizedProductionUrl("/llms.txt", locale), `site-graph.json should advertise ${localizeRoute("/llms.txt", locale)}` @@ -1379,7 +1877,7 @@ function auditSiteGraphArtifact({ routeEntries, structuredGraph }) { }); } -function main() { +async function main() { auditConfigSurface(); const structuredGraph = loadJson(STRUCTURED_GRAPH_PATH, "structured graph registry"); const { routeEntries, routes } = auditDocsSource(); @@ -1387,15 +1885,14 @@ function main() { auditHostedBuildOutput(structuredGraph); auditGeneratedTextArtifacts({ routeEntries, structuredGraph }); auditSiteGraphArtifact({ routeEntries, structuredGraph }); + await auditMarkdownDiscoveryWorker({ routeEntries, structuredGraph }); console.log( `Indexing surface audit passed for ${routes.length} explicit docs routes, ${routeEntries.filter((entry) => entry.hasFastnearOperation).length} docs operation pages, and ${structuredGraph.operations.filter((operation) => !isHiddenCanonicalRoute(operation.canonicalPath)).length} hosted operation pages.` ); } -try { - main(); -} catch (error) { +main().catch((error) => { console.error(`Indexing surface audit failed: ${error.message}`); process.exitCode = 1; -} +}); diff --git a/scripts/generate-ai-surfaces.js b/scripts/generate-ai-surfaces.js index 38478e6..0b335a0 100644 --- a/scripts/generate-ai-surfaces.js +++ b/scripts/generate-ai-surfaces.js @@ -1,5 +1,6 @@ #!/usr/bin/env node +const crypto = require("crypto"); const fs = require("fs"); const path = require("path"); const { isSecretQueryParam } = require("../src/utils/fastnearOperationUrlState"); @@ -29,6 +30,7 @@ const { const ROOT = path.resolve(__dirname, ".."); const DOCS_ROOT = path.resolve(ROOT, "docs"); const PAGE_MODELS_PATH = path.resolve(ROOT, "src/data/generatedFastnearPageModels.json"); +const OPENAPI_SNAPSHOTS_ROOT = path.resolve(ROOT, "src/data/openapiSnapshots"); const STRUCTURED_GRAPH_PATH = path.resolve( ROOT, "src/data/generatedFastnearStructuredGraph.json" @@ -39,12 +41,14 @@ const WEBSITE_ID = `${SITE_ORIGIN}/#website`; const ORGANIZATION_ID = `${SITE_ORIGIN}/#organization`; const ORGANIZATION_LOGO_URL = `${SITE_ORIGIN}/img/fastnear_logo_black.png`; const ORGANIZATION_SAME_AS = ["https://github.com/fastnear", "https://x.com/fast_near"]; +const AGENT_SKILLS_SCHEMA = "https://schemas.agentskills.io/discovery/0.2.0/schema.json"; const hideEarlyApiFamilies = /^(1|true|yes|on)$/i.test( process.env.HIDE_EARLY_API_FAMILIES || "" ); const GENERATED_STATIC_ROOTS = [ + path.join(STATIC_ROOT, ".well-known"), path.join(STATIC_ROOT, "docs"), path.join(STATIC_ROOT, "guides"), path.join(STATIC_ROOT, "rpc"), @@ -59,6 +63,7 @@ const GENERATED_STATIC_ROOTS = [ path.join(STATIC_ROOT, "transaction-flow"), path.join(STATIC_ROOT, "rpcs"), path.join(STATIC_ROOT, "apis"), + path.join(STATIC_ROOT, "openapi"), path.join(STATIC_ROOT, "structured-data"), ]; const GENERATED_STATIC_FILES = [ @@ -66,6 +71,107 @@ const GENERATED_STATIC_FILES = [ path.join(STATIC_ROOT, "llms.txt"), path.join(STATIC_ROOT, "llms-full.txt"), ]; +const OPENAPI_SNAPSHOT_FILES = { + fastnear: { + filePath: path.join(OPENAPI_SNAPSHOTS_ROOT, "fastnear.json"), + publishedPath: "/openapi/fastnear.json", + }, + neardata: { + filePath: path.join(OPENAPI_SNAPSHOTS_ROOT, "neardata.json"), + publishedPath: "/openapi/neardata.json", + }, +}; +const AGENT_SKILL_DEFINITIONS = [ + { + description: + "Operational entry point for FastNear agents. Use when you need the default workflow, discovery surfaces, and the first API to reach for.", + name: "overview", + route: "/agents", + }, + { + description: + "Surface-selection guide for FastNear. Use when you need to route a task to RPC, FastNear API, history APIs, NEAR Data, FastData, or snapshots.", + name: "surface-routing", + route: "/agents/choosing-surfaces", + }, + { + description: + "Authentication guidance for FastNear agents. Use when a task involves API keys, secret handling, or request authorization posture.", + name: "auth", + route: "/agents/auth", + }, + { + description: + "Common FastNear playbooks for agents. Use when you need the default multi-step workflow for holdings, transaction tracing, transfers, block monitoring, storage, or snapshots.", + name: "playbooks", + route: "/agents/playbooks", + }, +]; +const API_CATALOG_ENTRIES = [ + { + anchor: "https://rpc.mainnet.fastnear.com", + "service-desc": [ + { + href: "https://rpc.mainnet.fastnear.com/openapi.json", + type: "application/json", + }, + ], + "service-doc": [ + { + href: `${SITE_ORIGIN}/rpc`, + type: "text/html", + }, + ], + status: [ + { + href: "https://status.fastnear.com/status/main", + type: "text/html", + }, + ], + }, + { + anchor: "https://api.fastnear.com", + "service-desc": [ + { + href: `${SITE_ORIGIN}${OPENAPI_SNAPSHOT_FILES.fastnear.publishedPath}`, + type: "application/json", + }, + ], + "service-doc": [ + { + href: `${SITE_ORIGIN}/api`, + type: "text/html", + }, + ], + status: [ + { + href: "https://api.fastnear.com/status", + type: "application/json", + }, + ], + }, + { + anchor: "https://mainnet.neardata.xyz", + "service-desc": [ + { + href: `${SITE_ORIGIN}${OPENAPI_SNAPSHOT_FILES.neardata.publishedPath}`, + type: "application/json", + }, + ], + "service-doc": [ + { + href: `${SITE_ORIGIN}/neardata`, + type: "text/html", + }, + ], + status: [ + { + href: "https://mainnet.neardata.xyz/health", + type: "application/json", + }, + ], + }, +]; const API_SERVICE_LABELS = { en: { @@ -305,6 +411,10 @@ function writeTextFile(filePath, content) { fs.writeFileSync(filePath, content, "utf8"); } +function writeJsonFile(filePath, value) { + writeTextFile(filePath, `${JSON.stringify(value, null, 2)}\n`); +} + function normalizeRoute(route) { if (!route) { return "/"; @@ -393,12 +503,16 @@ function buildPageEntityId(url) { return `${url}#page`; } -function buildFamilyEntityId(familyId) { - return `${SITE_ORIGIN}/structured-data/families/${familyId}`; +function buildSiteGraphDocumentUrl(locale = DEFAULT_LOCALE) { + return buildLocalizedAbsoluteUrl("/structured-data/site-graph.json", locale); } -function buildOperationEntityId(pageModelId) { - return `${SITE_ORIGIN}/structured-data/operations/${pageModelId}`; +function buildFamilyEntityId(familyId, locale = DEFAULT_LOCALE) { + return `${buildSiteGraphDocumentUrl(locale)}#family-${familyId}`; +} + +function buildOperationEntityId(pageModelId, locale = DEFAULT_LOCALE) { + return `${buildSiteGraphDocumentUrl(locale)}#operation-${pageModelId}`; } function getDocsPageSchemaType(entry) { @@ -673,6 +787,7 @@ function transformInlineLinks(markdown, locale = DEFAULT_LOCALE) { function transformSimpleJsx(markdown, locale = DEFAULT_LOCALE) { let transformed = markdown + .replace(/\{\/\*[\s\S]*?\*\/\}/g, "") .replace(/<\/?React\.Fragment[^>]*>/g, "") .replace(//g, "") .replace(/([\s\S]*?)<\/strong>/g, "**$1**"); @@ -1533,7 +1648,7 @@ function buildSiteGraphFamilyRecord(family, locale = DEFAULT_LOCALE) { const docsUrl = buildAbsoluteUrl(docsPath); return { ...localizedFamily, - "@id": buildFamilyEntityId(family.id), + "@id": buildFamilyEntityId(family.id, locale), docsPageId: buildPageEntityId(docsUrl), docsPath, docsUrl, @@ -1554,7 +1669,7 @@ function buildSiteGraphOperationRecord(operation, locale = DEFAULT_LOCALE) { const canonicalUrl = buildAbsoluteUrl(canonicalPath); return { ...localizedOperation, - "@id": buildOperationEntityId(operation.pageModelId), + "@id": buildOperationEntityId(operation.pageModelId, locale), abstract: localizedOperation.summary || localizedOperation.name, canonicalPageId: buildPageEntityId(canonicalUrl), canonicalPath, @@ -1562,7 +1677,7 @@ function buildSiteGraphOperationRecord(operation, locale = DEFAULT_LOCALE) { docsPageId: buildPageEntityId(docsUrl), docsPath, docsUrl, - familyEntityId: buildFamilyEntityId(operation.familyId), + familyEntityId: buildFamilyEntityId(operation.familyId, locale), inLanguage: locale, mainEntityOfPageId: buildPageEntityId(docsUrl), publisherId: ORGANIZATION_ID, @@ -1615,8 +1730,10 @@ function buildSiteGraphArtifact({ authoredDocEntries, canonicalEntries, docEntri return { entityIds: { - familyIds: linkedFamilies.map((familyId) => buildFamilyEntityId(familyId)), - mainEntityId: linkedOperation ? buildOperationEntityId(linkedOperation.pageModelId) : null, + familyIds: linkedFamilies.map((familyId) => buildFamilyEntityId(familyId, locale)), + mainEntityId: linkedOperation + ? buildOperationEntityId(linkedOperation.pageModelId, locale) + : null, pageId: buildPageEntityId(url), }, indexable: true, @@ -1639,8 +1756,8 @@ function buildSiteGraphArtifact({ authoredDocEntries, canonicalEntries, docEntri const url = buildAbsoluteUrl(route); return { entityIds: { - familyIds: [buildFamilyEntityId(operation.familyId)], - mainEntityId: buildOperationEntityId(operation.pageModelId), + familyIds: [buildFamilyEntityId(operation.familyId, locale)], + mainEntityId: buildOperationEntityId(operation.pageModelId, locale), pageId: buildPageEntityId(url), }, indexable: false, @@ -1671,6 +1788,83 @@ function buildSiteGraphArtifact({ authoredDocEntries, canonicalEntries, docEntri }; } +function copyOpenApiSnapshots() { + Object.values(OPENAPI_SNAPSHOT_FILES).forEach(({ filePath, publishedPath }) => { + if (!fs.existsSync(filePath)) { + throw new Error(`Missing vendored OpenAPI snapshot: ${path.relative(ROOT, filePath)}`); + } + + const snapshot = JSON.parse(fs.readFileSync(filePath, "utf8")); + writeJsonFile(path.join(STATIC_ROOT, publishedPath.replace(/^\//, "")), snapshot); + }); +} + +function buildApiCatalogArtifact() { + return { + linkset: API_CATALOG_ENTRIES, + }; +} + +function quoteYamlString(value) { + return JSON.stringify(String(value)); +} + +function buildAgentSkillContent({ description, name, markdown }) { + const frontmatter = [ + "---", + `name: ${quoteYamlString(name)}`, + `description: ${quoteYamlString(description)}`, + "---", + "", + ].join("\n"); + + return `${frontmatter}${markdown}`; +} + +function computeSha256Digest(content) { + return `sha256:${crypto.createHash("sha256").update(content, "utf8").digest("hex")}`; +} + +function buildAgentSkillsArtifacts(entries) { + const entriesByRoute = Object.fromEntries(entries.map((entry) => [entry.route, entry])); + const skills = AGENT_SKILL_DEFINITIONS.map((definition) => { + const entry = entriesByRoute[definition.route]; + if (!entry) { + throw new Error(`Missing authored docs entry for agent skill route ${definition.route}`); + } + + const url = `/.well-known/agent-skills/${definition.name}/SKILL.md`; + const content = buildAgentSkillContent({ + description: definition.description, + name: definition.name, + markdown: entry.markdown, + }); + + return { + content, + description: definition.description, + digest: computeSha256Digest(content), + name: definition.name, + type: "skill-md", + url, + }; + }); + + return { + index: { + $schema: AGENT_SKILLS_SCHEMA, + skills: skills.map(({ description, digest, name, type, url }) => ({ + description, + digest, + name, + type, + url, + })), + }, + skills, + }; +} + function writeMirrorEntries(entries) { for (const entry of entries) { const markdownPaths = entry.markdownPaths || [entry.markdownPath]; @@ -1745,6 +1939,7 @@ function buildFullArchive(entries, locale = DEFAULT_LOCALE) { function main() { removeGeneratedStaticRoots(); + copyOpenApiSnapshots(); for (const locale of SUPPORTED_LOCALES) { const labels = getAuthoredMarkdownLabels(locale); @@ -1825,6 +2020,22 @@ function main() { )}\n` ); + if (locale === DEFAULT_LOCALE) { + writeJsonFile( + path.join(STATIC_ROOT, ".well-known/api-catalog"), + buildApiCatalogArtifact() + ); + + const agentSkills = buildAgentSkillsArtifacts(authoredDocEntries); + writeJsonFile( + path.join(STATIC_ROOT, ".well-known/agent-skills/index.json"), + agentSkills.index + ); + agentSkills.skills.forEach((skill) => { + writeTextFile(path.join(STATIC_ROOT, skill.url.replace(/^\//, "")), skill.content); + }); + } + if (wrapperDocEntries.length === 0) { throw new Error("Expected docs operation wrapper pages to generate Markdown mirrors."); } diff --git a/src/data/openapiSnapshots/fastnear.json b/src/data/openapiSnapshots/fastnear.json new file mode 100644 index 0000000..6c84c03 --- /dev/null +++ b/src/data/openapiSnapshots/fastnear.json @@ -0,0 +1,1324 @@ +{ + "components": { + "schemas": { + "AccountBalanceRow": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "balance": { + "nullable": true, + "type": "string" + } + }, + "required": [ + "account_id", + "balance" + ], + "type": "object" + }, + "AccountFullResponse": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "nfts": { + "items": { + "$ref": "#/components/schemas/NftRow" + }, + "type": "array" + }, + "pools": { + "items": { + "$ref": "#/components/schemas/PoolRow" + }, + "type": "array" + }, + "state": { + "allOf": [ + { + "$ref": "#/components/schemas/AccountStateResponse" + } + ], + "nullable": true, + "type": "object" + }, + "tokens": { + "items": { + "$ref": "#/components/schemas/TokenRow" + }, + "type": "array" + } + }, + "required": [ + "account_id", + "pools", + "tokens", + "nfts", + "state" + ], + "type": "object" + }, + "AccountStateResponse": { + "additionalProperties": false, + "properties": { + "balance": { + "nullable": true, + "type": "string" + }, + "locked": { + "nullable": true, + "type": "string" + }, + "storage_bytes": { + "format": "uint64", + "minimum": 0, + "nullable": true, + "type": "integer" + } + }, + "required": [ + "balance", + "locked", + "storage_bytes" + ], + "type": "object" + }, + "HealthResponse": { + "additionalProperties": false, + "properties": { + "status": { + "type": "string" + } + }, + "required": [ + "status" + ], + "type": "object" + }, + "NftRow": { + "additionalProperties": false, + "properties": { + "contract_id": { + "type": "string" + }, + "last_update_block_height": { + "format": "uint64", + "minimum": 0, + "nullable": true, + "type": "integer" + } + }, + "required": [ + "contract_id", + "last_update_block_height" + ], + "type": "object" + }, + "PoolRow": { + "additionalProperties": false, + "properties": { + "last_update_block_height": { + "format": "uint64", + "minimum": 0, + "nullable": true, + "type": "integer" + }, + "pool_id": { + "type": "string" + } + }, + "required": [ + "pool_id", + "last_update_block_height" + ], + "type": "object" + }, + "PublicKeyLookupResponse": { + "additionalProperties": false, + "properties": { + "account_ids": { + "items": { + "type": "string" + }, + "type": "array" + }, + "public_key": { + "type": "string" + } + }, + "required": [ + "public_key", + "account_ids" + ], + "type": "object" + }, + "StatusResponse": { + "additionalProperties": false, + "properties": { + "sync_balance_block_height": { + "format": "uint64", + "minimum": 0, + "nullable": true, + "type": "integer" + }, + "sync_block_height": { + "format": "uint64", + "minimum": 0, + "nullable": true, + "type": "integer" + }, + "sync_block_timestamp_nanosec": { + "nullable": true, + "type": "string" + }, + "sync_latency_sec": { + "format": "double", + "nullable": true, + "type": "number" + }, + "version": { + "type": "string" + } + }, + "required": [ + "version", + "sync_block_height", + "sync_latency_sec", + "sync_block_timestamp_nanosec", + "sync_balance_block_height" + ], + "type": "object" + }, + "TokenAccountsResponse": { + "additionalProperties": false, + "properties": { + "accounts": { + "items": { + "$ref": "#/components/schemas/AccountBalanceRow" + }, + "type": "array" + }, + "token_id": { + "type": "string" + } + }, + "required": [ + "token_id", + "accounts" + ], + "type": "object" + }, + "TokenRow": { + "additionalProperties": false, + "properties": { + "balance": { + "nullable": true, + "type": "string" + }, + "contract_id": { + "type": "string" + }, + "last_update_block_height": { + "format": "uint64", + "minimum": 0, + "nullable": true, + "type": "integer" + } + }, + "required": [ + "contract_id", + "last_update_block_height", + "balance" + ], + "type": "object" + }, + "V0ContractsResponse": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "contract_ids": { + "items": { + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "account_id", + "contract_ids" + ], + "type": "object" + }, + "V0StakingResponse": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "pools": { + "items": { + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "account_id", + "pools" + ], + "type": "object" + }, + "V1FtResponse": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "tokens": { + "items": { + "$ref": "#/components/schemas/TokenRow" + }, + "type": "array" + } + }, + "required": [ + "account_id", + "tokens" + ], + "type": "object" + }, + "V1NftResponse": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "tokens": { + "items": { + "$ref": "#/components/schemas/NftRow" + }, + "type": "array" + } + }, + "required": [ + "account_id", + "tokens" + ], + "type": "object" + }, + "V1StakingResponse": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "pools": { + "items": { + "$ref": "#/components/schemas/PoolRow" + }, + "type": "array" + } + }, + "required": [ + "account_id", + "pools" + ], + "type": "object" + } + } + }, + "info": { + "description": "Low-latency indexed account, token, and public-key lookup APIs for wallets and explorers. Embedded portal clients may forward an optional `apiKey` query parameter, but the public FastNEAR API does not require it.", + "title": "FastNEAR API", + "version": "3.0.3" + }, + "openapi": "3.0.3", + "paths": { + "/health": { + "get": { + "description": "Ping the FastNEAR API for liveness \u2014 returns `{status: ok}` when healthy.", + "operationId": "get_health", + "parameters": [ + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "status": "ok" + }, + "schema": { + "$ref": "#/components/schemas/HealthResponse" + } + } + }, + "description": "Health status string" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Get service health", + "tags": [ + "system" + ], + "x-fastnear-slug": "health", + "x-fastnear-title": "FastNEAR API - Health" + } + }, + "/status": { + "get": { + "description": "Check the current indexed block height, latency, and deployed service version.", + "operationId": "get_status", + "parameters": [ + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "sync_balance_block_height": 129734103, + "sync_block_height": 129734103, + "sync_block_timestamp_nanosec": "1728256282197171397", + "sync_latency_sec": 4.671730603, + "version": "0.10.0" + }, + "schema": { + "$ref": "#/components/schemas/StatusResponse" + } + } + }, + "description": "Current FastNEAR API sync status" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Get service sync status", + "tags": [ + "system" + ], + "x-fastnear-slug": "status", + "x-fastnear-title": "FastNEAR API - Status" + } + }, + "/v0/account/{account_id}/ft": { + "get": { + "description": "Fetch the fungible token contract IDs an account has held \u2014 contract IDs only, no balances.", + "operationId": "account_ft_v0", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "here.tg", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "here.tg", + "contract_ids": [ + "wrap.near", + "usdt.tether-token.near" + ] + }, + "schema": { + "$ref": "#/components/schemas/V0ContractsResponse" + } + } + }, + "description": "Fungible token contract IDs for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup fungible token contract IDs for an account", + "tags": [ + "fungible-tokens" + ], + "x-fastnear-slug": "account_ft", + "x-fastnear-title": "FastNEAR API - V0 Account FT" + } + }, + "/v0/account/{account_id}/nft": { + "get": { + "description": "Fetch the NFT contract IDs an account has held \u2014 contract IDs only, no block-height metadata.", + "operationId": "account_nft_v0", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "sharddog.near", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "sharddog.near", + "contract_ids": [ + "nft.example.near" + ] + }, + "schema": { + "$ref": "#/components/schemas/V0ContractsResponse" + } + } + }, + "description": "NFT contract IDs for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup NFT contract IDs for an account", + "tags": [ + "non-fungible-tokens" + ], + "x-fastnear-slug": "account_nft", + "x-fastnear-title": "FastNEAR API - V0 Account NFT" + } + }, + "/v0/account/{account_id}/staking": { + "get": { + "description": "Fetch staking pool account IDs for one account \u2014 pool IDs only, no block-height metadata.", + "operationId": "account_staking_v0", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "mob.near", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "mob.near", + "pools": [ + "zavodil.poolv1.near" + ] + }, + "schema": { + "$ref": "#/components/schemas/V0StakingResponse" + } + } + }, + "description": "Staking pool account IDs for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup staking pool account IDs for an account", + "tags": [ + "staking" + ], + "x-fastnear-slug": "account_staking", + "x-fastnear-title": "FastNEAR API - V0 Account Staking" + } + }, + "/v0/public_key/{public_key}": { + "get": { + "description": "Fetch the account IDs that have registered a full-access public key, via the legacy V0 lookup path.", + "operationId": "lookup_by_public_key_v0", + "parameters": [ + { + "description": "NEAR public key in `ed25519:...` or `secp256k1:...` form.", + "example": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT", + "in": "path", + "name": "public_key", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_ids": [ + "root.near" + ], + "public_key": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT" + }, + "schema": { + "$ref": "#/components/schemas/PublicKeyLookupResponse" + } + } + }, + "description": "Matching account IDs for the supplied full-access public key" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup full-access accounts by public key", + "tags": [ + "public-key" + ], + "x-fastnear-slug": "public_key_lookup", + "x-fastnear-title": "FastNEAR API - V0 Public Key Lookup" + } + }, + "/v0/public_key/{public_key}/all": { + "get": { + "description": "List every account tied to a public key \u2014 full-access and limited-access keys together \u2014 via the legacy V0 lookup-all path.", + "operationId": "lookup_by_public_key_all_v0", + "parameters": [ + { + "description": "NEAR public key in `ed25519:...` or `secp256k1:...` form.", + "example": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT", + "in": "path", + "name": "public_key", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_ids": [ + "root.near" + ], + "public_key": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT" + }, + "schema": { + "$ref": "#/components/schemas/PublicKeyLookupResponse" + } + } + }, + "description": "Matching account IDs for the supplied public key, including limited-access keys" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup all indexed accounts by public key", + "tags": [ + "public-key" + ], + "x-fastnear-slug": "public_key_lookup_all", + "x-fastnear-title": "FastNEAR API - V0 Public Key Lookup (All)" + } + }, + "/v1/account/{account_id}/ft": { + "get": { + "description": "Fetch an account's fungible token balance rows, each with contract ID, balance, and last-update block height.", + "operationId": "account_ft_v1", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "here.tg", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "here.tg", + "tokens": [ + { + "balance": "1000000000000000000000000", + "contract_id": "wrap.near", + "last_update_block_height": null + } + ] + }, + "schema": { + "$ref": "#/components/schemas/V1FtResponse" + } + } + }, + "description": "Indexed fungible token rows for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup indexed fungible token rows for an account", + "tags": [ + "fungible-tokens" + ], + "x-fastnear-slug": "account_ft", + "x-fastnear-title": "FastNEAR API - V1 Account FT" + } + }, + "/v1/account/{account_id}/full": { + "get": { + "description": "Fetch the combined indexed account view, including staking pools, FT balances, NFTs, and account state.", + "operationId": "account_full_v1", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "here.tg", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "here.tg", + "nfts": [], + "pools": [], + "state": { + "balance": "1000000000000000000000000", + "locked": "0", + "storage_bytes": 512 + }, + "tokens": [] + }, + "schema": { + "$ref": "#/components/schemas/AccountFullResponse" + } + } + }, + "description": "Full indexed account information for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup full indexed account information", + "tags": [ + "accounts" + ], + "x-fastnear-slug": "account_full", + "x-fastnear-title": "FastNEAR API - V1 Account Full" + } + }, + "/v1/account/{account_id}/nft": { + "get": { + "description": "Fetch NFT contract rows for an account, including block-height metadata for each contract.", + "operationId": "account_nft_v1", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "sharddog.near", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "sharddog.near", + "tokens": [ + { + "contract_id": "nft.example.near", + "last_update_block_height": null + } + ] + }, + "schema": { + "$ref": "#/components/schemas/V1NftResponse" + } + } + }, + "description": "Indexed NFT contract rows for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup indexed NFT contract rows for an account", + "tags": [ + "non-fungible-tokens" + ], + "x-fastnear-slug": "account_nft", + "x-fastnear-title": "FastNEAR API - V1 Account NFT" + } + }, + "/v1/account/{account_id}/staking": { + "get": { + "description": "Retrieve staking pool rows for an account, including block-height metadata for each pool relationship.", + "operationId": "account_staking_v1", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "mob.near", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "mob.near", + "pools": [ + { + "last_update_block_height": null, + "pool_id": "zavodil.poolv1.near" + } + ] + }, + "schema": { + "$ref": "#/components/schemas/V1StakingResponse" + } + } + }, + "description": "Indexed staking pool rows for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup indexed staking pools for an account", + "tags": [ + "staking" + ], + "x-fastnear-slug": "account_staking", + "x-fastnear-title": "FastNEAR API - V1 Account Staking" + } + }, + "/v1/ft/{token_id}/top": { + "get": { + "description": "Fetch the top-balance holder list for a fungible token contract, ranked highest balance first.", + "operationId": "ft_top_v1", + "parameters": [ + { + "description": "Fungible token contract account ID.", + "example": "wrap.near", + "in": "path", + "name": "token_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "accounts": [ + { + "account_id": "mob.near", + "balance": "979894691374420631019486155" + } + ], + "token_id": "wrap.near" + }, + "schema": { + "$ref": "#/components/schemas/TokenAccountsResponse" + } + } + }, + "description": "Indexed top holders for the requested fungible token" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup top indexed holders for a fungible token", + "tags": [ + "fungible-tokens" + ], + "x-fastnear-slug": "ft_top", + "x-fastnear-title": "FastNEAR API - V1 FT Top Holders" + } + }, + "/v1/public_key/{public_key}": { + "get": { + "description": "Resolve a full-access public key to the indexed NEAR accounts that have registered it \u2014 V1 canonical lookup path.", + "operationId": "lookup_by_public_key_v1", + "parameters": [ + { + "description": "NEAR public key in `ed25519:...` or `secp256k1:...` form.", + "example": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT", + "in": "path", + "name": "public_key", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_ids": [ + "root.near" + ], + "public_key": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT" + }, + "schema": { + "$ref": "#/components/schemas/PublicKeyLookupResponse" + } + } + }, + "description": "Matching account IDs for the supplied full-access public key" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup full-access accounts by public key", + "tags": [ + "public-key" + ], + "x-fastnear-slug": "public_key_lookup", + "x-fastnear-title": "FastNEAR API - V1 Public Key Lookup" + } + }, + "/v1/public_key/{public_key}/all": { + "get": { + "description": "Resolve a public key to every account that holds it \u2014 full-access and limited-access keys alike \u2014 via the V1 lookup-all path.", + "operationId": "lookup_by_public_key_all_v1", + "parameters": [ + { + "description": "NEAR public key in `ed25519:...` or `secp256k1:...` form.", + "example": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT", + "in": "path", + "name": "public_key", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_ids": [ + "root.near" + ], + "public_key": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT" + }, + "schema": { + "$ref": "#/components/schemas/PublicKeyLookupResponse" + } + } + }, + "description": "Matching account IDs for the supplied public key, including limited-access keys" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup all indexed accounts by public key", + "tags": [ + "public-key" + ], + "x-fastnear-slug": "public_key_lookup_all", + "x-fastnear-title": "FastNEAR API - V1 Public Key Lookup (All)" + } + } + }, + "servers": [ + { + "description": "Mainnet", + "url": "https://api.fastnear.com" + }, + { + "description": "Testnet", + "url": "https://test.api.fastnear.com" + } + ] +} diff --git a/src/data/openapiSnapshots/neardata.json b/src/data/openapiSnapshots/neardata.json new file mode 100644 index 0000000..b5dbbbd --- /dev/null +++ b/src/data/openapiSnapshots/neardata.json @@ -0,0 +1,1536 @@ +{ + "components": { + "schemas": { + "ActionDocument": { + "additionalProperties": true, + "type": "object" + }, + "ActionReceiptBody": { + "additionalProperties": false, + "properties": { + "Action": { + "$ref": "#/components/schemas/ActionReceiptDocument" + } + }, + "required": [ + "Action" + ], + "type": "object" + }, + "ActionReceiptDocument": { + "additionalProperties": false, + "properties": { + "actions": { + "items": { + "$ref": "#/components/schemas/ActionDocument" + }, + "type": "array" + }, + "gas_price": { + "type": "string" + }, + "input_data_ids": { + "items": { + "type": "string" + }, + "type": "array" + }, + "is_promise_yield": { + "type": "boolean" + }, + "output_data_receivers": { + "items": { + "$ref": "#/components/schemas/OutputDataReceiverDocument" + }, + "type": "array" + }, + "signer_id": { + "type": "string" + }, + "signer_public_key": { + "type": "string" + } + }, + "required": [ + "actions", + "gas_price", + "input_data_ids", + "is_promise_yield", + "output_data_receivers", + "signer_id", + "signer_public_key" + ], + "type": "object" + }, + "BlockDocument": { + "additionalProperties": false, + "description": "Full block document as served by neardata, including the block envelope and per-shard payloads.", + "properties": { + "block": { + "$ref": "#/components/schemas/BlockEnvelope" + }, + "shards": { + "items": { + "$ref": "#/components/schemas/ShardDocument" + }, + "type": "array" + } + }, + "required": [ + "block", + "shards" + ], + "type": "object" + }, + "BlockEnvelope": { + "additionalProperties": false, + "description": "Block-level payload returned by neardata.", + "properties": { + "author": { + "description": "Block producer account ID.", + "type": "string" + }, + "chunks": { + "items": { + "$ref": "#/components/schemas/ChunkHeader" + }, + "type": "array" + }, + "header": { + "$ref": "#/components/schemas/BlockHeader" + } + }, + "required": [ + "author", + "chunks", + "header" + ], + "type": "object" + }, + "BlockErrorResponse": { + "additionalProperties": false, + "properties": { + "error": { + "type": "string" + }, + "type": { + "$ref": "#/components/schemas/BlockErrorType" + } + }, + "required": [ + "error", + "type" + ], + "type": "object" + }, + "BlockErrorType": { + "enum": [ + "BLOCK_HEIGHT_TOO_HIGH", + "BLOCK_HEIGHT_TOO_LOW", + "BLOCK_DOES_NOT_EXIST" + ], + "type": "string" + }, + "BlockHeader": { + "additionalProperties": true, + "description": "Block header object as served by neardata.", + "properties": { + "chunks_included": { + "format": "uint64", + "type": "integer" + }, + "epoch_id": { + "type": "string" + }, + "gas_price": { + "type": "string" + }, + "hash": { + "type": "string" + }, + "height": { + "format": "uint64", + "type": "integer" + }, + "next_epoch_id": { + "type": "string" + }, + "prev_hash": { + "type": "string" + }, + "prev_height": { + "format": "uint64", + "type": "integer" + }, + "timestamp": { + "type": "integer" + }, + "timestamp_nanosec": { + "type": "string" + }, + "total_supply": { + "type": "string" + } + }, + "type": "object" + }, + "ChunkDocument": { + "additionalProperties": false, + "description": "Chunk payload returned by neardata for a single shard in a selected block.", + "properties": { + "author": { + "description": "Chunk producer account ID.", + "type": "string" + }, + "header": { + "$ref": "#/components/schemas/ChunkHeader" + }, + "receipts": { + "items": { + "$ref": "#/components/schemas/ReceiptDocument" + }, + "type": "array" + }, + "transactions": { + "items": { + "$ref": "#/components/schemas/ChunkTransactionWrapper" + }, + "type": "array" + } + }, + "required": [ + "author", + "header", + "receipts", + "transactions" + ], + "type": "object" + }, + "ChunkHeader": { + "additionalProperties": true, + "description": "Chunk header object as served by neardata.", + "properties": { + "chunk_hash": { + "type": "string" + }, + "gas_limit": { + "type": "integer" + }, + "gas_used": { + "type": "integer" + }, + "height_created": { + "format": "uint64", + "type": "integer" + }, + "height_included": { + "format": "uint64", + "type": "integer" + }, + "outcome_root": { + "type": "string" + }, + "outgoing_receipts_root": { + "type": "string" + }, + "prev_block_hash": { + "type": "string" + }, + "shard_id": { + "format": "uint64", + "type": "integer" + }, + "tx_root": { + "type": "string" + } + }, + "type": "object" + }, + "ChunkTransactionWrapper": { + "additionalProperties": false, + "description": "Transaction entry returned inside a neardata chunk.", + "properties": { + "outcome": { + "$ref": "#/components/schemas/ExecutionWithReceipt" + }, + "transaction": { + "$ref": "#/components/schemas/SignedTransactionDocument" + } + }, + "required": [ + "outcome", + "transaction" + ], + "type": "object" + }, + "DataReceiptBody": { + "additionalProperties": false, + "properties": { + "Data": { + "$ref": "#/components/schemas/DataReceiptDocument" + } + }, + "required": [ + "Data" + ], + "type": "object" + }, + "DataReceiptDocument": { + "additionalProperties": false, + "properties": { + "data": { + "type": "string" + }, + "data_id": { + "type": "string" + }, + "is_promise_resume": { + "type": "boolean" + } + }, + "required": [ + "data", + "data_id", + "is_promise_resume" + ], + "type": "object" + }, + "ExecutionOutcomeDocument": { + "additionalProperties": false, + "properties": { + "block_hash": { + "type": "string" + }, + "id": { + "type": "string" + }, + "outcome": { + "$ref": "#/components/schemas/ExecutionOutcomeSummary" + }, + "proof": { + "items": { + "$ref": "#/components/schemas/ExecutionProofItem" + }, + "type": "array" + } + }, + "required": [ + "block_hash", + "id", + "outcome", + "proof" + ], + "type": "object" + }, + "ExecutionOutcomeStatus": { + "oneOf": [ + { + "$ref": "#/components/schemas/ExecutionOutcomeStatusSuccessReceiptId" + }, + { + "$ref": "#/components/schemas/ExecutionOutcomeStatusSuccessValue" + }, + { + "$ref": "#/components/schemas/ExecutionOutcomeStatusFailure" + } + ] + }, + "ExecutionOutcomeStatusFailure": { + "additionalProperties": false, + "properties": { + "Failure": { + "additionalProperties": true, + "type": "object" + } + }, + "required": [ + "Failure" + ], + "type": "object" + }, + "ExecutionOutcomeStatusSuccessReceiptId": { + "additionalProperties": false, + "properties": { + "SuccessReceiptId": { + "type": "string" + } + }, + "required": [ + "SuccessReceiptId" + ], + "type": "object" + }, + "ExecutionOutcomeStatusSuccessValue": { + "additionalProperties": false, + "properties": { + "SuccessValue": { + "type": "string" + } + }, + "required": [ + "SuccessValue" + ], + "type": "object" + }, + "ExecutionOutcomeSummary": { + "additionalProperties": false, + "properties": { + "executor_id": { + "type": "string" + }, + "gas_burnt": { + "format": "uint64", + "type": "integer" + }, + "logs": { + "items": { + "type": "string" + }, + "type": "array" + }, + "metadata": { + "additionalProperties": true, + "type": "object" + }, + "receipt_ids": { + "items": { + "type": "string" + }, + "type": "array" + }, + "status": { + "$ref": "#/components/schemas/ExecutionOutcomeStatus" + }, + "tokens_burnt": { + "type": "string" + } + }, + "required": [ + "executor_id", + "gas_burnt", + "logs", + "metadata", + "receipt_ids", + "status", + "tokens_burnt" + ], + "type": "object" + }, + "ExecutionProofItem": { + "additionalProperties": true, + "type": "object" + }, + "ExecutionWithReceipt": { + "additionalProperties": false, + "description": "Execution result paired with an optional receipt object.", + "properties": { + "execution_outcome": { + "$ref": "#/components/schemas/ExecutionOutcomeDocument" + }, + "receipt": { + "description": "Receipt payload when neardata includes it for this entry.", + "nullable": true, + "oneOf": [ + { + "$ref": "#/components/schemas/ReceiptDocument" + }, + { + "$ref": "#/components/schemas/OmittedReceiptDocument" + } + ], + "type": "object" + }, + "tx_hash": { + "type": "string" + } + }, + "required": [ + "execution_outcome", + "receipt" + ], + "type": "object" + }, + "HealthResponse": { + "additionalProperties": false, + "properties": { + "status": { + "type": "string" + } + }, + "required": [ + "status" + ], + "type": "object" + }, + "OmittedReceiptDocument": { + "additionalProperties": false, + "type": "object" + }, + "OutputDataReceiverDocument": { + "additionalProperties": false, + "properties": { + "data_id": { + "type": "string" + }, + "receiver_id": { + "type": "string" + } + }, + "required": [ + "data_id", + "receiver_id" + ], + "type": "object" + }, + "ReceiptBody": { + "oneOf": [ + { + "$ref": "#/components/schemas/ActionReceiptBody" + }, + { + "$ref": "#/components/schemas/DataReceiptBody" + } + ] + }, + "ReceiptDocument": { + "additionalProperties": false, + "description": "Receipt object as served by neardata inside a chunk payload.", + "properties": { + "predecessor_id": { + "type": "string" + }, + "priority": { + "format": "uint64", + "type": "integer" + }, + "receipt": { + "$ref": "#/components/schemas/ReceiptBody" + }, + "receipt_id": { + "type": "string" + }, + "receiver_id": { + "type": "string" + } + }, + "required": [ + "predecessor_id", + "priority", + "receipt", + "receipt_id", + "receiver_id" + ], + "type": "object" + }, + "ShardDocument": { + "additionalProperties": false, + "description": "Per-shard payload returned by neardata for a block.", + "properties": { + "chunk": { + "$ref": "#/components/schemas/ChunkDocument" + }, + "receipt_execution_outcomes": { + "items": { + "$ref": "#/components/schemas/ExecutionWithReceipt" + }, + "type": "array" + }, + "shard_id": { + "format": "uint64", + "type": "integer" + }, + "state_changes": { + "items": { + "$ref": "#/components/schemas/StateChangeItem" + }, + "type": "array" + } + }, + "required": [ + "chunk", + "receipt_execution_outcomes", + "shard_id", + "state_changes" + ], + "type": "object" + }, + "SignedTransactionDocument": { + "additionalProperties": false, + "properties": { + "actions": { + "items": { + "$ref": "#/components/schemas/ActionDocument" + }, + "type": "array" + }, + "hash": { + "type": "string" + }, + "nonce": { + "format": "uint64", + "type": "integer" + }, + "priority_fee": { + "format": "uint64", + "type": "integer" + }, + "public_key": { + "type": "string" + }, + "receiver_id": { + "type": "string" + }, + "signature": { + "type": "string" + }, + "signer_id": { + "type": "string" + } + }, + "required": [ + "actions", + "hash", + "nonce", + "priority_fee", + "public_key", + "receiver_id", + "signature", + "signer_id" + ], + "type": "object" + }, + "StateChangeCause": { + "oneOf": [ + { + "$ref": "#/components/schemas/StateChangeCauseTransactionProcessing" + }, + { + "$ref": "#/components/schemas/StateChangeCauseReceiptProcessing" + }, + { + "$ref": "#/components/schemas/StateChangeCauseActionReceiptGasReward" + } + ] + }, + "StateChangeCauseActionReceiptGasReward": { + "additionalProperties": false, + "properties": { + "receipt_hash": { + "type": "string" + }, + "type": { + "type": "string" + } + }, + "required": [ + "receipt_hash", + "type" + ], + "type": "object" + }, + "StateChangeCauseReceiptProcessing": { + "additionalProperties": false, + "properties": { + "receipt_hash": { + "type": "string" + }, + "type": { + "type": "string" + } + }, + "required": [ + "receipt_hash", + "type" + ], + "type": "object" + }, + "StateChangeCauseTransactionProcessing": { + "additionalProperties": false, + "properties": { + "tx_hash": { + "type": "string" + }, + "type": { + "type": "string" + } + }, + "required": [ + "tx_hash", + "type" + ], + "type": "object" + }, + "StateChangeItem": { + "additionalProperties": false, + "description": "State change entry returned by neardata for a shard.", + "properties": { + "cause": { + "$ref": "#/components/schemas/StateChangeCause" + }, + "change": { + "$ref": "#/components/schemas/StateChangeValue" + }, + "type": { + "type": "string" + } + }, + "required": [ + "cause", + "change", + "type" + ], + "type": "object" + }, + "StateChangeValue": { + "oneOf": [ + { + "$ref": "#/components/schemas/StateChangeValueAccountUpdate" + }, + { + "$ref": "#/components/schemas/StateChangeValueAccessKeyUpdate" + }, + { + "$ref": "#/components/schemas/StateChangeValueDataUpdate" + }, + { + "$ref": "#/components/schemas/StateChangeValueDataDeletion" + } + ] + }, + "StateChangeValueAccessKeyUpdate": { + "additionalProperties": false, + "properties": { + "access_key": { + "additionalProperties": true, + "type": "object" + }, + "account_id": { + "type": "string" + }, + "public_key": { + "type": "string" + } + }, + "required": [ + "access_key", + "account_id", + "public_key" + ], + "type": "object" + }, + "StateChangeValueAccountUpdate": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "amount": { + "type": "string" + }, + "code_hash": { + "type": "string" + }, + "locked": { + "type": "string" + }, + "storage_paid_at": { + "format": "uint64", + "type": "integer" + }, + "storage_usage": { + "format": "uint64", + "type": "integer" + } + }, + "required": [ + "account_id", + "amount", + "code_hash", + "locked", + "storage_paid_at", + "storage_usage" + ], + "type": "object" + }, + "StateChangeValueDataDeletion": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "key_base64": { + "type": "string" + } + }, + "required": [ + "account_id", + "key_base64" + ], + "type": "object" + }, + "StateChangeValueDataUpdate": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "key_base64": { + "type": "string" + }, + "value_base64": { + "type": "string" + } + }, + "required": [ + "account_id", + "key_base64", + "value_base64" + ], + "type": "object" + } + } + }, + "info": { + "description": "Cached and archived NEAR block data with redirect helpers for first-block and latest-block workflows. Some block-family routes may redirect depending on archive or freshness topology.", + "title": "NEAR Data API", + "version": "3.0.3" + }, + "openapi": "3.0.3", + "paths": { + "/health": { + "get": { + "description": "Ping the neardata service for liveness \u2014 returns `{status: ok}` when healthy, errors otherwise.", + "operationId": "get_health", + "parameters": [ + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "status": "ok" + }, + "schema": { + "$ref": "#/components/schemas/HealthResponse" + } + } + }, + "description": "Health payload" + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Get service health", + "tags": [ + "system" + ], + "x-fastnear-slug": "health", + "x-fastnear-title": "NEAR Data API - Health" + } + }, + "/v0/block/{block_height}": { + "get": { + "description": "Fetch a finalized block's full document at a chosen height \u2014 header plus every chunk and shard payload.", + "operationId": "get_block", + "parameters": [ + { + "description": "NEAR block height to retrieve.", + "example": "50000000", + "in": "path", + "name": "block_height", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDocument", + "nullable": true + } + } + }, + "description": "Requested document, or `null` when the selected slice is absent" + }, + "302": { + "description": "Redirect to a canonical archive or finalized block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "404": { + "content": { + "application/json": { + "example": { + "error": "The block does not exist in this archive range", + "type": "BLOCK_DOES_NOT_EXIST" + }, + "schema": { + "$ref": "#/components/schemas/BlockErrorResponse" + } + } + }, + "description": "Structured block-height error" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Fetch a finalized block by height", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "block", + "x-fastnear-title": "NEAR Data API - Block" + } + }, + "/v0/block/{block_height}/chunk/{shard_id}": { + "get": { + "description": "Fetch one chunk \u2014 a single shard's transactions and incoming receipts \u2014 at a chosen block height.", + "operationId": "get_chunk", + "parameters": [ + { + "description": "NEAR block height to retrieve.", + "example": "50000000", + "in": "path", + "name": "block_height", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Shard ID whose chunk should be returned.", + "example": "0", + "in": "path", + "name": "shard_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ChunkDocument", + "nullable": true + } + } + }, + "description": "Requested document, or `null` when the selected slice is absent" + }, + "302": { + "description": "Redirect to a canonical archive or finalized block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "404": { + "content": { + "application/json": { + "example": { + "error": "The block does not exist in this archive range", + "type": "BLOCK_DOES_NOT_EXIST" + }, + "schema": { + "$ref": "#/components/schemas/BlockErrorResponse" + } + } + }, + "description": "Structured block-height error" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Fetch one chunk from a finalized block", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "block_chunk", + "x-fastnear-title": "NEAR Data API - Block Chunk" + } + }, + "/v0/block/{block_height}/headers": { + "get": { + "description": "Fetch only a finalized block's header and chunk summaries \u2014 no per-shard payload.", + "operationId": "get_block_headers", + "parameters": [ + { + "description": "NEAR block height to retrieve.", + "example": "50000000", + "in": "path", + "name": "block_height", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockEnvelope", + "nullable": true + } + } + }, + "description": "Requested document, or `null` when the selected slice is absent" + }, + "302": { + "description": "Redirect to a canonical archive or finalized block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "404": { + "content": { + "application/json": { + "example": { + "error": "The block does not exist in this archive range", + "type": "BLOCK_DOES_NOT_EXIST" + }, + "schema": { + "$ref": "#/components/schemas/BlockErrorResponse" + } + } + }, + "description": "Structured block-height error" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Fetch the block-level object for a finalized block", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "block_headers", + "x-fastnear-title": "NEAR Data API - Block Headers" + } + }, + "/v0/block/{block_height}/shard/{shard_id}": { + "get": { + "description": "Fetch one shard's full payload at a chosen block \u2014 chunk plus state changes and produced receipts.", + "operationId": "get_shard", + "parameters": [ + { + "description": "NEAR block height to retrieve.", + "example": "50000000", + "in": "path", + "name": "block_height", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Shard ID to return.", + "example": "0", + "in": "path", + "name": "shard_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ShardDocument", + "nullable": true + } + } + }, + "description": "Requested document, or `null` when the selected slice is absent" + }, + "302": { + "description": "Redirect to a canonical archive or finalized block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "404": { + "content": { + "application/json": { + "example": { + "error": "The block does not exist in this archive range", + "type": "BLOCK_DOES_NOT_EXIST" + }, + "schema": { + "$ref": "#/components/schemas/BlockErrorResponse" + } + } + }, + "description": "Structured block-height error" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Fetch one shard from a finalized block", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "block_shard", + "x-fastnear-title": "NEAR Data API - Block Shard" + } + }, + "/v0/block_opt/{block_height}": { + "get": { + "description": "Fetch an optimistic (not-yet-final) block at a chosen height \u2014 may redirect once the optimistic window has finalized.", + "operationId": "get_block_optimistic", + "parameters": [ + { + "description": "NEAR block height to retrieve.", + "example": "50000000", + "in": "path", + "name": "block_height", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDocument", + "nullable": true + } + } + }, + "description": "Requested document, or `null` when the selected slice is absent" + }, + "302": { + "description": "Redirect to a canonical archive or finalized block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "404": { + "content": { + "application/json": { + "example": { + "error": "The block does not exist in this archive range", + "type": "BLOCK_DOES_NOT_EXIST" + }, + "schema": { + "$ref": "#/components/schemas/BlockErrorResponse" + } + } + }, + "description": "Structured block-height error" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Fetch an optimistic block by height", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "block_optimistic", + "x-fastnear-title": "NEAR Data API - Optimistic Block" + } + }, + "/v0/first_block": { + "get": { + "description": "Redirect to the chain's first post-genesis block \u2014 a starting cursor for indexers backfilling from the beginning.", + "operationId": "get_first_block", + "parameters": [ + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDocument", + "nullable": true + } + } + }, + "description": "Full block document returned after automatic redirect following" + }, + "302": { + "description": "Redirect to the canonical first block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + } + }, + "summary": "Redirect to the first block after genesis", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "first_block", + "x-fastnear-title": "NEAR Data API - First Block" + } + }, + "/v0/last_block/final": { + "get": { + "description": "Redirect to the most recent finalized block \u2014 the chain-tip cursor once consensus has settled.", + "operationId": "get_last_block_final", + "parameters": [ + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDocument", + "nullable": true + } + } + }, + "description": "Full block document returned after automatic redirect following" + }, + "302": { + "description": "Redirect to the latest block block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Redirect to the latest finalized block", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "last_block_final", + "x-fastnear-title": "NEAR Data API - Last Final Block" + } + }, + "/v0/last_block/optimistic": { + "get": { + "description": "Redirect to the most recent optimistic block \u2014 the freshest-possible tip, ahead of final settlement.", + "operationId": "get_last_block_optimistic", + "parameters": [ + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDocument", + "nullable": true + } + } + }, + "description": "Full block document returned after automatic redirect following" + }, + "302": { + "description": "Redirect to the latest block block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Redirect to the latest optimistic block", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "last_block_optimistic", + "x-fastnear-title": "NEAR Data API - Last Optimistic Block" + } + } + }, + "servers": [ + { + "description": "Mainnet", + "url": "https://mainnet.neardata.xyz" + }, + { + "description": "Testnet", + "url": "https://testnet.neardata.xyz" + } + ] +} diff --git a/static/.well-known/agent-skills/auth/SKILL.md b/static/.well-known/agent-skills/auth/SKILL.md new file mode 100644 index 0000000..df0e69e --- /dev/null +++ b/static/.well-known/agent-skills/auth/SKILL.md @@ -0,0 +1,99 @@ +--- +name: "auth" +description: "Authentication guidance for FastNear agents. Use when a task involves API keys, secret handling, or request authorization posture." +--- +**Source:** [https://docs.fastnear.com/agents/auth](https://docs.fastnear.com/agents/auth) + +# Auth for Agents + +Agents should authenticate to FastNear the same way production backends do. Do not copy the browser-demo posture used by the docs UI into an agent, worker, or automation runtime. + +One FastNear API key works across the RPC and API endpoints. Many public reads still work without a key. For agents, the important question is not whether auth exists. It is where the credential lives, how it gets attached to requests, and how to avoid leaking it into prompts, logs, or browser state. + +## If you only need the rule + +- Store the key in an env var or secret manager. +- Inject it server-side or from the worker runtime. +- Prefer the `Authorization: Bearer ...` header. +- Apply the same key and transport rules to both regular and archival RPC hosts. +- Never ask a user to paste a FastNear key into chat, a prompt, or a browser-only agent. + +## Recommended runtime patterns + +Use one of these patterns: + +- **Server-side worker or automation**: load the key from env vars or a secret manager and attach it directly to outbound FastNear requests. +- **Thin backend proxy**: if the user-facing app runs in the browser, send the request to your backend first and let the backend inject the FastNear credential. +- **Multi-tenant service**: keep per-tenant keys in a proper secrets store and make the agent select the right credential by tenant or project context. + +Avoid browser-only agent architectures that need the FastNear key in client-side storage. + +## Choose the credential transport + +| Transport | Use it when... | Notes | +| --- | --- | --- | +| `Authorization: Bearer ${API_KEY}` | you control the HTTP client or backend | Best default for agents. Less likely to leak into URL logs, analytics, or copied links. | +| `?apiKey=${API_KEY}` | you are using simple curl or a system that cannot easily set headers | Still valid, but URLs tend to travel further through logs and tooling. Use it intentionally. | + +If you have a choice, use the header form. + +## Minimum secure flow + +1. Read the key from an env var or secret manager at runtime. +2. Attach it to the request as a header or query parameter. +3. Keep prompts, traces, and logs scrubbed so the raw key never lands in transcripts. +4. Rotate the key if it appears in a prompt, debug trace, browser storage, or a copied URL. + +Example: + +```js +const apiKey = process.env.FASTNEAR_API_KEY; + +const response = await fetch('https://rpc.mainnet.fastnear.com', { + method: 'POST', + headers: { + 'Authorization': `Bearer ${apiKey}`, + 'Content-Type': 'application/json', + }, + body: JSON.stringify({ + jsonrpc: '2.0', + id: 1, + method: 'block', + params: {finality: 'final'}, + }), +}); +``` + +## When auth is missing + +Many public FastNear endpoints are still readable without a key. If the agent can answer the user's question from public traffic, do that. + +When a key is required for higher limits, paid access, or authenticated traffic: + +- tell the user to create or retrieve a key from [dashboard.fastnear.com](https://dashboard.fastnear.com) +- ask them to configure it in an env var, secret manager, or backend configuration +- do not ask them to paste the raw key into chat so the agent can carry it around + +If the agent cannot access the configured secret, it should say that clearly and stop rather than improvising insecure storage. + +## Do not do this + +- Do not lift a key out of browser `localStorage` and treat it as an agent credential. +- Do not embed keys into browser-delivered agent apps. +- Do not keep keys in prompts, notebook cells, or plaintext config checked into source control. +- Do not prefer `?apiKey=` just because it is shorter if your infrastructure logs full URLs aggressively. + +## What the agent should tell a user + +When auth is relevant, a useful agent answer usually contains: + +- whether the current request can proceed unauthenticated +- whether the user needs to configure a FastNear API key next +- where that key should live, usually env vars, a secret manager, or a backend proxy +- which transport the agent is using, usually `Authorization: Bearer ...` + +## Related guides + +- [Auth & Access](https://docs.fastnear.com/auth) +- [Agents on FastNear](https://docs.fastnear.com/agents) +- [Choosing the Right Surface](https://docs.fastnear.com/agents/choosing-surfaces) diff --git a/static/.well-known/agent-skills/index.json b/static/.well-known/agent-skills/index.json new file mode 100644 index 0000000..068d7f9 --- /dev/null +++ b/static/.well-known/agent-skills/index.json @@ -0,0 +1,33 @@ +{ + "$schema": "https://schemas.agentskills.io/discovery/0.2.0/schema.json", + "skills": [ + { + "description": "Operational entry point for FastNear agents. Use when you need the default workflow, discovery surfaces, and the first API to reach for.", + "digest": "sha256:e45e8632c088e252dc5e445d50c7883a87d63eab06b872471f3f855486336ec1", + "name": "overview", + "type": "skill-md", + "url": "/.well-known/agent-skills/overview/SKILL.md" + }, + { + "description": "Surface-selection guide for FastNear. Use when you need to route a task to RPC, FastNear API, history APIs, NEAR Data, FastData, or snapshots.", + "digest": "sha256:4e74891dad49f3a1e619e7e447f84991b13439bf31621885e8d1e59d00217b12", + "name": "surface-routing", + "type": "skill-md", + "url": "/.well-known/agent-skills/surface-routing/SKILL.md" + }, + { + "description": "Authentication guidance for FastNear agents. Use when a task involves API keys, secret handling, or request authorization posture.", + "digest": "sha256:70af39bbfb033f5fa65f4bc135b16a61b074de21a5b3b8a9d24c85fc496303b0", + "name": "auth", + "type": "skill-md", + "url": "/.well-known/agent-skills/auth/SKILL.md" + }, + { + "description": "Common FastNear playbooks for agents. Use when you need the default multi-step workflow for holdings, transaction tracing, transfers, block monitoring, storage, or snapshots.", + "digest": "sha256:dfe12a735e69b6dd3a21cfffe32c2c64cd55e47200ba156106a5b91c31735e8e", + "name": "playbooks", + "type": "skill-md", + "url": "/.well-known/agent-skills/playbooks/SKILL.md" + } + ] +} diff --git a/static/.well-known/agent-skills/overview/SKILL.md b/static/.well-known/agent-skills/overview/SKILL.md new file mode 100644 index 0000000..3c1c8d0 --- /dev/null +++ b/static/.well-known/agent-skills/overview/SKILL.md @@ -0,0 +1,141 @@ +--- +name: "overview" +description: "Operational entry point for FastNear agents. Use when you need the default workflow, discovery surfaces, and the first API to reach for." +--- +**Source:** [https://docs.fastnear.com/agents](https://docs.fastnear.com/agents) + +# Agents on FastNear + +This page is the operational starting point for AI agents, crawlers, and automation runtimes using FastNear. The goal is simple: identify the user's actual task, choose one FastNear API first, fetch the smallest useful result, and only widen to another API when there is a clear missing piece. + +## If you only need the next step + +- Need to decide which FastNear API to start with? Use [Choosing the Right Surface](https://docs.fastnear.com/agents/choosing-surfaces). +- Need credential handling rules? Use [Auth for Agents](https://docs.fastnear.com/agents/auth). +- Need example multi-step workflows? Use [Agent Playbooks](https://docs.fastnear.com/agents/playbooks). +- Need exact endpoint docs now? Go directly to [RPC Reference](https://docs.fastnear.com/rpc), [FastNear API](https://docs.fastnear.com/api), [Transactions API](https://docs.fastnear.com/tx), [Transfers API](https://docs.fastnear.com/transfers), [NEAR Data API](https://docs.fastnear.com/neardata), or [KV FastData API](https://docs.fastnear.com/fastdata/kv). + +## FastNear for agents in one minute + +- Use indexed APIs when the user wants a product-shaped answer such as balances, holdings, account history, or transfer history. +- Use [RPC Reference](https://docs.fastnear.com/rpc) when the user needs canonical protocol-native fields, contract calls, or transaction submission. +- Use [NEAR Data API](https://docs.fastnear.com/neardata) when the question is about recent optimistic or finalized blocks and explicit polling. +- Use [Snapshots](https://docs.fastnear.com/snapshots) for operator workflows, not application-level data reads. +- One FastNear API key works across the RPC and API endpoints. +- Stop after the first sufficient answer. Do not collect from multiple APIs unless the current result is insufficient. + +## What to resolve before the first request + +Try to identify these inputs before you make a call: + +- **Network**: mainnet or testnet. +- **Primary identifier**: account ID, public key, transaction hash, receipt ID, block height/hash, contract ID plus storage key, or node/bootstrap task. +- **Answer shape**: summary, history, canonical protocol output, or operator instructions. +- **Freshness requirement**: historical, current, optimistic/latest, or finalized/latest. +- **Precision requirement**: indexed summary is acceptable, or exact canonical node semantics are required. + +If one of these is missing, make a small assumption when the likely starting API does not change. Ask a clarifying question only when the wrong API choice would materially change the result. + +## FastNear APIs at a glance + +| API | Start here when... | Typical inputs | Widen only if... | +| --- | --- | --- | --- | +| [FastNear API](https://docs.fastnear.com/api) | The user wants balances, NFTs, staking, public-key resolution, or an account summary | `account_id`, public key | The user needs exact canonical node fields | +| [RPC Reference](https://docs.fastnear.com/rpc) | The user wants canonical protocol output, contract calls, validator data, or transaction submission | `account_id`, block height/hash, method-specific params | The user also needs a higher-level summary or indexed history | +| [Transactions API](https://docs.fastnear.com/tx) | The user wants transaction, receipt, account, or block execution history | transaction hash, receipt ID, `account_id`, block identifiers | The user needs exact RPC-level follow-up or finality semantics | +| [Transfers API](https://docs.fastnear.com/transfers) | The user wants transfer-only history | `account_id`, transfer filters | The question broadens to general execution context | +| [NEAR Data API](https://docs.fastnear.com/neardata) | The user wants recent optimistic or finalized blocks, headers, or latest-block helpers | block height/hash, freshness requirement | The user needs exact canonical block/state follow-up | +| [KV FastData API](https://docs.fastnear.com/fastdata/kv) | The user wants indexed contract key history or latest indexed key-value state | contract ID, storage key | The user needs exact on-chain current state | +| [Snapshots](https://docs.fastnear.com/snapshots) | The user is standing up infrastructure | network, node type, operator goal | The user shifts to application-level chain questions | + +## Default workflow + +Use this loop unless the task clearly needs something more specialized: + +1. Translate the user's wording into the task they actually need solved. + Examples: account summary, canonical state inspection, transaction investigation, transfer-only history, recent block monitoring, or node bootstrap. +2. Pick one FastNear API first. + Do not gather from multiple APIs until the first result proves insufficient. +3. Pull the smallest relevant docs context. + Use the API index page, endpoint page, or Markdown mirror instead of broad unrelated docs. +4. Make the first request that matches the user's identifier and expected answer shape. +5. Stop if the result is already sufficient to answer the user's question. +6. Widen only when you can name the missing piece precisely. + Examples: canonical confirmation, broader execution history, fresher block-family data, or exact protocol fields. + +## Good defaults + +When the user's wording is short but the intent is common, these defaults are usually correct: + +- "Check this account" usually starts with [FastNear API](https://docs.fastnear.com/api). +- "Check this public key" usually starts with [FastNear API](https://docs.fastnear.com/api) for key-to-account resolution. +- "Check this transaction" usually starts with [Transactions API](https://docs.fastnear.com/tx). +- "Check this receipt" usually starts with [Transactions API](https://docs.fastnear.com/tx). +- "Check this block" usually starts with [NEAR Data API](https://docs.fastnear.com/neardata) for recent-block monitoring or [RPC Reference](https://docs.fastnear.com/rpc) for exact canonical block data. +- "Check this contract key/history" usually starts with [KV FastData API](https://docs.fastnear.com/fastdata/kv). +- "Help me bootstrap a node" starts with [Snapshots](https://docs.fastnear.com/snapshots). + +Full routing rules and tradeoffs live in [Choosing the Right Surface](https://docs.fastnear.com/agents/choosing-surfaces). + +## Widen carefully + +Good escalation patterns: + +- Start with [FastNear API](https://docs.fastnear.com/api), then move to [RPC Reference](https://docs.fastnear.com/rpc) if the user asks for exact canonical confirmation. +- Start with [Transactions API](https://docs.fastnear.com/tx), then move to [RPC Reference](https://docs.fastnear.com/rpc) if the user needs protocol-level transaction or receipt follow-up. +- Start with [Transfers API](https://docs.fastnear.com/transfers), then widen to [Transactions API](https://docs.fastnear.com/tx) if the user broadens the question beyond transfer events. +- Start with [NEAR Data API](https://docs.fastnear.com/neardata), then move to [RPC Reference](https://docs.fastnear.com/rpc) if the user needs exact canonical block or state inspection. + +Bad pattern: + +- Pull from several FastNear APIs before you know what the user actually needs. That usually produces a noisier answer, not a better one. + +## Authenticate once, reuse everywhere + +Public endpoints often work without a key. Add a key for higher limits, a shared authenticated posture, or paid access patterns. The same key works across every FastNear API above, including the regular and archival RPC hosts; send it either as an HTTP header or a URL parameter: + +```bash title="Authorization header" +curl "https://rpc.mainnet.fastnear.com" \ + -H "Authorization: Bearer ${API_KEY}" \ + -H "Content-Type: application/json" \ + --data '{"method":"block","params":{"finality":"final"},"id":1,"jsonrpc":"2.0"}' +``` + +```bash title="URL parameter" +curl "https://rpc.mainnet.fastnear.com?apiKey=${API_KEY}" +``` + +Get a key from [dashboard.fastnear.com](https://dashboard.fastnear.com). Operational posture for non-interactive runtimes: [Auth for Agents](https://docs.fastnear.com/agents/auth) — keys go in env vars or a secret manager, never in browser storage, chat logs, or prompts. Full flow and header details: [Auth & Access](https://docs.fastnear.com/auth). + +## Pull clean docs into a prompt + +- Every page has a **Copy Markdown** button in the top-right toolbar. It emits a navigation-chrome-free Markdown version of the page, ready to paste into a prompt or RAG store. +- The `llms.txt` convention is mirrored here: + - [`/llms.txt`](https://docs.fastnear.com/llms.txt) — index of pages and short descriptions. + - [`/llms-full.txt`](https://docs.fastnear.com/llms-full.txt) — the full docs corpus concatenated into one file. + - Russian-locale equivalents live at [`/ru/llms.txt`](https://docs.fastnear.com/llms.txt) and [`/ru/llms-full.txt`](https://docs.fastnear.com/llms-full.txt). +- Machine-readable site structure for graph-aware ingestion: [`/structured-data/site-graph.json`](https://docs.fastnear.com/structured-data/site-graph.json) (mirrored in `/ru/`). +- Per-page Markdown mirrors live under the same slug with a `.md` suffix if you prefer direct fetches over the Copy Markdown button. + +## Per-call hints an agent should know + +- Parameter names, response fields, and example payloads are rendered live on each endpoint page. The underlying registry lives at `src/data/generatedFastnearPageModels.json` if you are mirroring schema into another system. +- `?network=testnet` is supported on specific pages only. Each page calls out its network support in the **Auth and availability** section; do not assume it works globally. +- Pagination tokens (`resume_token`, `page_token`) are opaque. Reuse them verbatim and only with the endpoint plus filter set that produced them. +- Status routes: every REST family ships a `/status` and `/health` path for liveness and sync-latency inspection. + +## What a useful agent answer should contain + +- A brief statement of which FastNear API was used and why, especially if the choice was an inference. +- The answer in the shape the user is likely to need next: summary first for humans, exact fields or next-call guidance when the caller is technical. +- Any important caveat about freshness, canonicality, pagination, or network choice. +- A follow-up path only when it is likely to help. + Examples: "use RPC for canonical confirmation" or "use Transactions API if you need broader execution context." + +Avoid dumping raw payloads when the user is really asking for interpretation. + +## Next docs by need + +- Need routing depth and tradeoffs? [Choosing the Right Surface](https://docs.fastnear.com/agents/choosing-surfaces) +- Need credential posture and secret handling? [Auth for Agents](https://docs.fastnear.com/agents/auth) +- Need example workflows? [Agent Playbooks](https://docs.fastnear.com/agents/playbooks) diff --git a/static/.well-known/agent-skills/playbooks/SKILL.md b/static/.well-known/agent-skills/playbooks/SKILL.md new file mode 100644 index 0000000..50a6b4c --- /dev/null +++ b/static/.well-known/agent-skills/playbooks/SKILL.md @@ -0,0 +1,264 @@ +--- +name: "playbooks" +description: "Common FastNear playbooks for agents. Use when you need the default multi-step workflow for holdings, transaction tracing, transfers, block monitoring, storage, or snapshots." +--- +**Source:** [https://docs.fastnear.com/agents/playbooks](https://docs.fastnear.com/agents/playbooks) + +# Agent Playbooks + +Use this page when the agent already knows the kind of task it is handling and needs the default next steps. Each playbook starts with one FastNear API, names the minimum useful inputs, and tells you when to stop versus when to widen. + +The core rule stays the same across all playbooks: start with one API, get the smallest useful result, and only widen when you can name the missing piece. + +## How to use these playbooks + +1. Match the user's request to the closest playbook below. +2. Gather the minimum inputs. +3. Make the first request from the suggested starting API. +4. Stop as soon as you can answer in the shape the user actually needs. +5. Widen only for a specific missing field, freshness requirement, or canonicality requirement. + +## Quick map + +| If the user wants... | Start with... | Widen only if... | +| --- | --- | --- | +| account balances, holdings, staking, or wallet-style summary | [FastNear API](https://docs.fastnear.com/api) | exact canonical node fields are required | +| transaction, receipt, or account execution history | [Transactions API](https://docs.fastnear.com/tx) | exact RPC-level status or submission semantics are required | +| transfer-only history | [Transfers API](https://docs.fastnear.com/transfers) | the question broadens beyond transfers | +| latest optimistic or finalized blocks | [NEAR Data API](https://docs.fastnear.com/neardata) | exact canonical block or state follow-up is required | +| indexed contract key state or key history | [KV FastData API](https://docs.fastnear.com/fastdata/kv) | exact current on-chain state is required | +| node bootstrap or operator setup | [Snapshots](https://docs.fastnear.com/snapshots) | the task shifts back to application-level chain data | + +If you still are not sure which one applies, use [Choosing the Right Surface](https://docs.fastnear.com/agents/choosing-surfaces) first. + +## Account summary and holdings + +Use this when the user says things like "check this account", "what does this wallet hold", "what NFTs does this account have", or "which account does this key belong to?" + +**Minimum inputs** + +- network +- `account_id` or public key +- whether the user wants a broad summary or one specific asset class + +**Start here** + +- [V1 Full Account View](https://docs.fastnear.com/api/v1/account-full) for the broad account summary +- [V1 Public Key Lookup](https://docs.fastnear.com/api/v1/public-key) when the starting identifier is a public key +- [FastNear API index](https://docs.fastnear.com/api) when you need to choose a narrower endpoint first + +**Default sequence** + +1. If the starting identifier is a public key, resolve it to one or more account IDs with [V1 Public Key Lookup](https://docs.fastnear.com/api/v1/public-key). +2. Fetch the broadest useful account view with [V1 Full Account View](https://docs.fastnear.com/api/v1/account-full). +3. If the user asked for only one asset family or needs narrower detail, move to the targeted endpoints such as [FT balances](https://docs.fastnear.com/api/v1/account-ft), [NFT holdings](https://docs.fastnear.com/api/v1/account-nft), or [staking positions](https://docs.fastnear.com/api/v1/account-staking). +4. Stop once you can answer the holdings question directly. + +**Widen only if** + +- the user asks for exact canonical state fields rather than indexed summary data +- the user needs protocol-native account or access-key semantics + +When that happens, widen to [View Account](https://docs.fastnear.com/rpc/account/view-account) or other relevant pages in [RPC Reference](https://docs.fastnear.com/rpc). + +**A useful answer should contain** + +- the account identity you resolved +- the balances or holdings the user asked about +- a brief note if the answer is indexed summary data rather than raw RPC state + +## Transaction or receipt investigation + +Use this when the user says things like "did this transaction succeed", "why did it fail", "what happened to this receipt", or "show recent activity for this account." + +**Minimum inputs** + +- network +- transaction hash, receipt ID, or `account_id` +- whether the user wants one item inspected or a history range + +**Start here** + +- [Transactions by Hash](https://docs.fastnear.com/tx/transactions) for a transaction hash +- [Receipt Lookup](https://docs.fastnear.com/tx/receipt) for a receipt ID +- [Account History](https://docs.fastnear.com/tx/account) for account-centric activity + +**Default sequence** + +1. Choose the starting endpoint that matches the identifier you already have. +2. Fetch the indexed execution record and reconstruct the execution story in readable order. +3. Pull out the status, affected accounts, major receipts, and the block context if that is relevant. +4. Stop if you can explain what happened without needing canonical RPC confirmation. + +**Widen only if** + +- the user explicitly asks for exact RPC status semantics +- the indexed record is not enough to answer a protocol-level question +- the question shifts into transaction submission behavior + +When that happens, widen to [Transaction Status](https://docs.fastnear.com/rpc/transaction/tx-status) or another relevant method in [RPC Reference](https://docs.fastnear.com/rpc). + +**A useful answer should contain** + +- whether the transaction or receipt succeeded, failed, or is still pending +- the main execution takeaway first, before raw fields +- any follow-up path only if it adds value, such as "use RPC for canonical confirmation" + +## Transfer-only history + +Use this when the user cares about asset movement and does not need broader receipt or action context. + +**Minimum inputs** + +- network +- `account_id` +- optional filters such as token, direction, or time range + +**Start here** + +- [Query Transfers](https://docs.fastnear.com/transfers/query) +- [Transfers API index](https://docs.fastnear.com/transfers) + +**Default sequence** + +1. Query transfer history for the relevant account and filters. +2. Use pagination only as far as needed to answer the question. +3. Keep the answer focused on transfers rather than reconstructing the full transaction story. +4. Stop if the user only asked who sent what, when, and in what asset. + +**Widen only if** + +- the user starts asking about non-transfer actions +- the user needs receipt traces or broader execution context +- the user wants to explain why an action happened, not just that a transfer occurred + +When that happens, widen to [Account History](https://docs.fastnear.com/tx/account) or another relevant page in [Transactions API](https://docs.fastnear.com/tx). + +**A useful answer should contain** + +- the incoming or outgoing transfer events that matter +- any filter assumptions you made +- a note that this is transfer history, not full execution history + +## Recent block monitoring + +Use this when the user wants the latest optimistic or finalized block-family data, or asks "what changed recently?" + +**Minimum inputs** + +- network +- freshness requirement: optimistic or finalized +- optional block height or hash if the user is anchoring to a specific block + +**Start here** + +- [Last Final Block Redirect](https://docs.fastnear.com/neardata/last-block-final) for the latest finalized head +- [Optimistic Block by Height](https://docs.fastnear.com/neardata/block-optimistic) when the workflow is explicitly optimistic +- [Block Headers](https://docs.fastnear.com/neardata/block-headers) when header-level polling is enough +- [NEAR Data API index](https://docs.fastnear.com/neardata) when you need to choose among these + +**Default sequence** + +1. Decide whether the user needs optimistic freshness or finalized stability. +2. Use the latest-block helper or block-family route that matches that freshness requirement. +3. Poll explicitly and keep the answer clear about what freshness mode you used. +4. Stop if the user only needs recent block-family information and not canonical protocol follow-up. + +**Widen only if** + +- the user asks for exact canonical block output +- the user wants to inspect state or protocol fields beyond the block-family data +- the user needs exact RPC semantics for a specific block follow-up + +When that happens, widen to [RPC Reference](https://docs.fastnear.com/rpc), usually starting with [Block by Height](https://docs.fastnear.com/rpc/block/block-by-height) or [Block by Id](https://docs.fastnear.com/rpc/block/block-by-id). + +**A useful answer should contain** + +- whether the data came from optimistic or finalized reads +- the latest block or header details that actually answer the user's question +- a note when a deeper canonical follow-up would materially change interpretation + +## Contract storage inspection + +Use this when the user wants indexed contract key history, latest indexed key state, or contract-storage analysis by key. + +**Minimum inputs** + +- network +- contract ID +- exact key, key prefix, or account/predecessor scope +- whether the user wants latest indexed state or historical key changes + +**Start here** + +- [GET Latest by Exact Key](https://docs.fastnear.com/fastdata/kv/get-latest-key) for one exact key +- [KV FastData API index](https://docs.fastnear.com/fastdata/kv) when the question is broader than one key + +**Default sequence** + +1. Decide whether the user wants one key, a key family, or account-scoped storage history. +2. Fetch the smallest indexed key-value view that matches that scope. +3. If the user needs history rather than the latest value, stay inside [KV FastData API](https://docs.fastnear.com/fastdata/kv) and switch to the matching history endpoint. +4. Stop if indexed key-value data already answers the question. + +**Widen only if** + +- the user needs exact current on-chain state rather than indexed storage state +- the user needs protocol-native contract-state semantics +- the indexed storage view is insufficient for the exact key or prefix requested + +When that happens, widen to [View State](https://docs.fastnear.com/rpc/contract/view-state) in [RPC Reference](https://docs.fastnear.com/rpc). + +**A useful answer should contain** + +- the contract and key scope you inspected +- whether the result is latest indexed state or key history +- a note if canonical RPC state would differ in freshness or semantics + +## Node bootstrap and operator setup + +Use this when the user is trying to get infrastructure online rather than query chain data. + +**Minimum inputs** + +- network +- node type, such as RPC or archival +- whether the goal is bootstrap speed, sync recovery, or an operational runbook + +**Start here** + +- [Snapshots](https://docs.fastnear.com/snapshots) + +**Default sequence** + +1. Route immediately to the relevant snapshot or operator guide. +2. Keep the answer focused on prerequisites, bootstrap path, and operational next steps. +3. Do not pull application-level APIs unless the user later changes the task. + +**Widen only if** + +- the user stops asking about infrastructure and starts asking about chain data itself + +When that happens, return to [Choosing the Right Surface](https://docs.fastnear.com/agents/choosing-surfaces) and pick the correct data API from there. + +**A useful answer should contain** + +- the network and node type you are assuming +- the operator steps the user should follow next +- any clear prerequisite or caveat that changes the bootstrap path + +## Cross-playbook rules + +- State the network if you had to infer it. +- State the API you chose if the choice was an inference. +- Prefer one sufficient answer over an exhaustive multi-API answer. +- Treat pagination tokens as opaque and reuse them only with the endpoint and filter set that produced them. +- Do not widen just because a more canonical API exists. + +## If no playbook fits cleanly + +If the request is still ambiguous after reading this page: + +- use [Choosing the Right Surface](https://docs.fastnear.com/agents/choosing-surfaces) to pick the first API +- use [Auth for Agents](https://docs.fastnear.com/agents/auth) if the blocker is credential handling +- return to [Agents on FastNear](https://docs.fastnear.com/agents) for the default workflow and answer-shape rules diff --git a/static/.well-known/agent-skills/surface-routing/SKILL.md b/static/.well-known/agent-skills/surface-routing/SKILL.md new file mode 100644 index 0000000..3a1bcec --- /dev/null +++ b/static/.well-known/agent-skills/surface-routing/SKILL.md @@ -0,0 +1,259 @@ +--- +name: "surface-routing" +description: "Surface-selection guide for FastNear. Use when you need to route a task to RPC, FastNear API, history APIs, NEAR Data, FastData, or snapshots." +--- +**Source:** [https://docs.fastnear.com/agents/choosing-surfaces](https://docs.fastnear.com/agents/choosing-surfaces) + +# Choosing the Right Surface + +Do not start by exposing every FastNear API to an agent. Start by translating the user's request into the job they actually want done, then pick the one FastNear API or reference section that most directly answers that job. + +For agents, the important question is usually not "which endpoint exists?" It is "what kind of answer will help the user next?" + +## What decides the route + +Before you pick an API, identify four things: + +- **Object**: account, public key, transaction hash, receipt, block, contract storage, or infrastructure setup. +- **Answer shape**: product-style summary, execution history, canonical protocol output, or operator instructions. +- **Freshness**: historical, current, or latest/near-realtime. +- **Exactness**: indexed summary is acceptable, or canonical node-shaped correctness is required. + +In practice: + +- account plus summary usually means [FastNear API](https://docs.fastnear.com/api) +- account plus exact canonical state usually means [RPC Reference](https://docs.fastnear.com/rpc) +- transaction or receipt usually means [Transactions API](https://docs.fastnear.com/tx) +- transfer-only history usually means [Transfers API](https://docs.fastnear.com/transfers) +- newest blocks usually means [NEAR Data API](https://docs.fastnear.com/neardata) +- contract key history usually means [KV FastData API](https://docs.fastnear.com/fastdata/kv) +- node bootstrap usually means [Snapshots](https://docs.fastnear.com/snapshots) + +## Start from user intent + +- If the user wants a wallet-style or explorer-style answer, prefer indexed APIs. +- If the user wants canonical protocol behavior or exact node-shaped state, use raw [RPC Reference](https://docs.fastnear.com/rpc). +- If the user wants history, receipts, or event sequences, use history-oriented APIs before falling back to RPC. +- If the user wants the newest block-family data, use [NEAR Data API](https://docs.fastnear.com/neardata) for polling-oriented freshness. +- If the user wants infrastructure bootstrap instructions, route them to [Snapshots](https://docs.fastnear.com/snapshots) instead of application query surfaces. + +## Decision ladder + +Use this order of operations before you pick a surface: + +1. Is the user trying to stand up infrastructure rather than query chain data? + If yes, use [Snapshots](https://docs.fastnear.com/snapshots). +2. Is the user asking for a product-shaped summary such as balances, NFTs, staking, or account holdings? + If yes, start with [FastNear API](https://docs.fastnear.com/api). +3. Is the user asking what happened over time: transactions, receipts, transfers, or activity history? + If yes, start with [Transactions API](https://docs.fastnear.com/tx) or [Transfers API](https://docs.fastnear.com/transfers) for transfer-only questions. +4. Is the user focused on the newest blocks or low-latency block-family reads? + If yes, use [NEAR Data API](https://docs.fastnear.com/neardata). +5. Does correctness depend on canonical node behavior, protocol fields, or exact on-chain state? + If yes, use [RPC Reference](https://docs.fastnear.com/rpc). +6. Is the user asking about indexed key-value storage history or latest indexed contract state? + If yes, use [KV FastData API](https://docs.fastnear.com/fastdata/kv). + +If more than one surface could work, prefer the one that gives the most directly useful answer with the least reconstruction by the agent. + +## Before the first call + +Try to resolve these inputs before you make a request: + +- network: mainnet or testnet +- primary identifier: account ID, public key, transaction hash, receipt ID, block height/hash, contract ID plus storage key +- expected output: summary, history, canonical fields, or operator steps +- freshness requirement: latest, finalized, historical, or "whatever is current" + +If one of these is missing: + +- make a small assumption when the likely starting API does not change +- ask a clarifying question only when the wrong choice would materially change the result + +## Route common user asks + +| If the user says... | They probably want... | Start here | Only switch when... | +| --- | --- | --- | --- | +| "What is the exact on-chain account state?" | Canonical protocol-native state | [RPC Reference](https://docs.fastnear.com/rpc) | You also need a higher-level summary for humans. | +| "What does this account own?" | Product-shaped balances, NFTs, staking, and holdings | [FastNear API](https://docs.fastnear.com/api) | You need exact node fields the indexed view does not expose. | +| "What activity touched this account?" | Indexed transaction and receipt history | [Transactions API](https://docs.fastnear.com/tx) | The user only wants transfer events, or you need canonical protocol follow-up details. | +| "Show me transfers only." | Account-centric transfer history | [Transfers API](https://docs.fastnear.com/transfers) | The user actually needs broader transaction execution context. | +| "What changed in the latest blocks?" | Fresh optimistic or finalized block-family reads | [NEAR Data API](https://docs.fastnear.com/neardata) | You need canonical RPC details for a specific block or state read. | +| "What is the contract storage history here?" | Indexed key-value state history | [KV FastData API](https://docs.fastnear.com/fastdata/kv) | You need current canonical on-chain state rather than indexed history. | +| "Why did this transaction fail?" | An execution timeline first, then canonical details | [Transactions API](https://docs.fastnear.com/tx) | You need RPC-level confirmation of final protocol status or transaction submission behavior. | +| "How do I submit a transaction or inspect a protocol field?" | Canonical node behavior | [RPC Reference](https://docs.fastnear.com/rpc) | You later need to summarize the resulting account state or activity for a human. | +| "How do I bootstrap a node or archival setup?" | Infrastructure workflow, not app data | [Snapshots](https://docs.fastnear.com/snapshots) | The user then starts asking application-level chain questions. | + +## When the identifier is the clue + +If the user's wording is vague but the identifier is clear, let the identifier shape your first move: + +| If you have... | Default first move | Why | +| --- | --- | --- | +| an `account_id` | Start with [FastNear API](https://docs.fastnear.com/api) for summaries, or [RPC Reference](https://docs.fastnear.com/rpc) if the user explicitly asks for exact state | Account questions usually mean balances/holdings first unless the user says canonical. | +| a public key | Start with [FastNear API](https://docs.fastnear.com/api) for key-to-account resolution | This is usually an account discovery task, not an RPC-first task. | +| a transaction hash | Start with [Transactions API](https://docs.fastnear.com/tx) | Most users want execution context and readable history before raw protocol fields. | +| a receipt ID | Start with [Transactions API](https://docs.fastnear.com/tx) | Receipt tracing is already indexed there. | +| a block height or block hash | Start with [NEAR Data API](https://docs.fastnear.com/neardata) for freshness-oriented monitoring, or [RPC Reference](https://docs.fastnear.com/rpc) for exact canonical block data | The user's need is usually either recency or canonicality. | +| a contract ID plus storage key | Start with [KV FastData API](https://docs.fastnear.com/fastdata/kv) for indexed key history, or [RPC Reference](https://docs.fastnear.com/rpc) for exact current chain state | The storage question usually decides whether indexed history or canonical state matters. | +| a node or archival setup task | Start with [Snapshots](https://docs.fastnear.com/snapshots) | This is operator workflow, not application data access. | + +## What each surface is best at + +### RPC Reference + +Use [RPC Reference](https://docs.fastnear.com/rpc) when the user needs exact protocol-native data or behavior: + +- exact account state, access keys, validators, chunks, blocks, protocol metadata +- contract view calls and transaction submission +- answers where field names and semantics should stay close to NEAR nodes + +Do not lead with RPC when the user really wants a clean summary of holdings or history. That forces the agent to rebuild a product-shaped answer from lower-level data. + +### FastNear API + +Use [FastNear API](https://docs.fastnear.com/api) when the user wants an answer that already looks like application data: + +- balances +- NFTs +- staking positions +- public-key lookups +- combined account snapshots + +This should usually be the first stop for wallet, portfolio, explorer, and account overview requests. + +### Transactions API + +Use [Transactions API](https://docs.fastnear.com/tx) when the user wants execution history: + +- account activity +- transaction lookup +- receipt tracing +- block-scoped transaction history + +This is the default history surface when the user asks "what happened?" rather than "what exists right now?" + +### Transfers API + +Use [Transfers API](https://docs.fastnear.com/transfers) when the user's question is explicitly about transfer events and not full execution context: + +- incoming and outgoing transfers +- transfer-centric pagination flows +- transfer-only account activity views + +If the user starts asking about receipts, non-transfer actions, or full transaction behavior, move up to [Transactions API](https://docs.fastnear.com/tx). + +### NEAR Data API + +Use [NEAR Data API](https://docs.fastnear.com/neardata) when freshness matters more than a product-shaped summary: + +- optimistic or recently finalized blocks +- latest block-family reads +- explicit polling workflows + +Do not present this as a websocket or webhook product. It is a polling-oriented read surface. + +### KV FastData API + +Use [KV FastData API](https://docs.fastnear.com/fastdata/kv) when the question is about indexed contract storage history or latest indexed key-value state: + +- storage analysis +- key history +- contract state lookups where indexed key-value access is the right abstraction + +### Snapshots + +Use [Snapshots](https://docs.fastnear.com/snapshots) when the workflow is about operators standing up infrastructure: + +- mainnet or testnet bootstrap +- RPC or archival node initialization +- operator runbooks + +This is not an application query path. + +## Immediate next steps after choosing + +Once you choose a starting API, the next move should also be predictable: + +| Chosen API | First thing to do | What success looks like | Widen only if... | +| --- | --- | --- | --- | +| [FastNear API](https://docs.fastnear.com/api) | Pick the endpoint that matches the user's identifier or summary request | You can answer balances, holdings, staking, or account-summary questions directly | The user needs exact canonical node fields or protocol-native confirmation | +| [RPC Reference](https://docs.fastnear.com/rpc) | Choose the exact RPC method that matches the object and the required canonical field set | You can return protocol-native fields or perform the exact state/submit action requested | The user also needs a higher-level summary or indexed history | +| [Transactions API](https://docs.fastnear.com/tx) | Start from the transaction hash, receipt, account history, or block-history endpoint that matches the question | You can explain what happened and in what order | The user needs exact RPC-level finality or submission semantics | +| [Transfers API](https://docs.fastnear.com/transfers) | Fetch transfer history for the account or asset scope in question | You can answer transfer-only questions without unrelated execution detail | The user broadens the question to receipts, actions, or full transaction context | +| [NEAR Data API](https://docs.fastnear.com/neardata) | Fetch the latest optimistic or finalized block-family data that matches the freshness requirement | You can answer "what changed recently?" or "what is the latest block-family state?" | The user needs exact canonical block/state follow-up | +| [KV FastData API](https://docs.fastnear.com/fastdata/kv) | Fetch latest indexed key-value state or indexed key history | You can answer contract storage inspection questions in indexed form | The user needs exact on-chain current state instead of indexed storage views | +| [Snapshots](https://docs.fastnear.com/snapshots) | Choose the right network and node type, then follow the bootstrap guide | You can give operator steps, prerequisites, and bootstrap guidance | The user shifts from infra setup to application-level chain queries | + +## Stop conditions before you widen + +Do not widen to a second API just because it exists. Stay on the first API when: + +- the answer already matches the user's expected shape +- the current API already exposes the fields the user asked about +- the user asked for history and you already have indexed history +- the user asked for a summary and you already have a summary + +Widen when: + +- the user explicitly asks for canonical confirmation +- the current API lacks the field, freshness, or execution detail required +- the user broadens from transfer-only history to general transaction behavior +- the user broadens from summary output to protocol-native inspection + +## Combine surfaces only when it helps the user + +Good multi-surface patterns: + +- Start with [FastNear API](https://docs.fastnear.com/api), then drop to [RPC Reference](https://docs.fastnear.com/rpc) if the user asks for exact canonical confirmation. +- Start with [Transactions API](https://docs.fastnear.com/tx), then use [RPC Reference](https://docs.fastnear.com/rpc) if you need final protocol details for a specific transaction or receipt. +- Start with [NEAR Data API](https://docs.fastnear.com/neardata) for the newest blocks, then use [RPC Reference](https://docs.fastnear.com/rpc) for exact follow-up inspection of a specific block or state query. +- Start with [Transfers API](https://docs.fastnear.com/transfers) for transfer-only questions, then widen to [Transactions API](https://docs.fastnear.com/tx) if the user asks for more execution context. + +Bad multi-surface pattern: + +- Pull data from several surfaces before you know what the user actually wants. That usually produces a noisier answer, not a better one. + +## What the agent should infer from common phrasing + +- "What does this wallet have?" usually means balances, NFTs, staking, and maybe public-key resolution. Start with [FastNear API](https://docs.fastnear.com/api). +- "Why did this transaction fail?" usually means the user wants a readable execution story first, not raw protocol output. Start with [Transactions API](https://docs.fastnear.com/tx). +- "Is this the exact chain state?" usually means canonical correctness matters more than convenience. Start with [RPC Reference](https://docs.fastnear.com/rpc). +- "What just happened in the last block?" usually means freshness is the main requirement. Start with [NEAR Data API](https://docs.fastnear.com/neardata). +- "How do I get a node online quickly?" is an operator workflow. Start with [Snapshots](https://docs.fastnear.com/snapshots). + +## Common routing mistakes + +- Do not start with RPC just because it is canonical. Canonical is not the same as helpful for every user task. +- Do not use snapshots for application-level reads. +- Do not describe [NEAR Data API](https://docs.fastnear.com/neardata) as a streaming surface. +- Do not widen from transfer history to full transaction history unless the user's question actually broadens. +- Do not switch away from an indexed API just because raw RPC exists. Switch only when the indexed answer is insufficient. + +## If user intent is ambiguous + +When the user is vague, make the smallest useful routing assumption: + +- "Check this account" should usually begin with [FastNear API](https://docs.fastnear.com/api), because most users want a readable account summary. +- "Check this transaction" should usually begin with [Transactions API](https://docs.fastnear.com/tx), because most users want execution context, not only protocol fields. +- "Check this block" can start with [NEAR Data API](https://docs.fastnear.com/neardata) for recency-oriented monitoring or [RPC Reference](https://docs.fastnear.com/rpc) when the user explicitly cares about canonical node output. + +If you do make an assumption, state it briefly in the answer and move forward. Ask for clarification only when choosing the wrong surface would materially change the result. + +## What the agent should do after the first result + +After the first response comes back: + +1. Check whether you can now answer the user's question directly. +2. If yes, answer in the user's expected shape instead of collecting more data. +3. If no, name the missing piece precisely. + Examples: canonical confirmation, broader history, fresher block data, exact protocol field, or infra-specific context. +4. Only then switch APIs. + +The goal is not to prove that multiple FastNear APIs exist. The goal is to answer the user's next real question with the fewest necessary steps. + +## Related guides + +- [Agents on FastNear](https://docs.fastnear.com/agents) for the full surface map, base URLs, and prompt-ingestion hints. +- [Auth for Agents](https://docs.fastnear.com/agents/auth) for credential handling and runtime posture. +- [Agent Playbooks](https://docs.fastnear.com/agents/playbooks) for example multi-step workflows. diff --git a/static/.well-known/api-catalog b/static/.well-known/api-catalog new file mode 100644 index 0000000..12425cd --- /dev/null +++ b/static/.well-known/api-catalog @@ -0,0 +1,67 @@ +{ + "linkset": [ + { + "anchor": "https://rpc.mainnet.fastnear.com", + "service-desc": [ + { + "href": "https://rpc.mainnet.fastnear.com/openapi.json", + "type": "application/json" + } + ], + "service-doc": [ + { + "href": "https://docs.fastnear.com/rpc", + "type": "text/html" + } + ], + "status": [ + { + "href": "https://status.fastnear.com/status/main", + "type": "text/html" + } + ] + }, + { + "anchor": "https://api.fastnear.com", + "service-desc": [ + { + "href": "https://docs.fastnear.com/openapi/fastnear.json", + "type": "application/json" + } + ], + "service-doc": [ + { + "href": "https://docs.fastnear.com/api", + "type": "text/html" + } + ], + "status": [ + { + "href": "https://api.fastnear.com/status", + "type": "application/json" + } + ] + }, + { + "anchor": "https://mainnet.neardata.xyz", + "service-desc": [ + { + "href": "https://docs.fastnear.com/openapi/neardata.json", + "type": "application/json" + } + ], + "service-doc": [ + { + "href": "https://docs.fastnear.com/neardata", + "type": "text/html" + } + ], + "status": [ + { + "href": "https://mainnet.neardata.xyz/health", + "type": "application/json" + } + ] + } + ] +} diff --git a/static/_headers b/static/_headers new file mode 100644 index 0000000..5284c5b --- /dev/null +++ b/static/_headers @@ -0,0 +1,117 @@ +/ + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-doc"; type="text/html" + Link: ; rel="service-meta"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/ru + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-doc"; type="text/html" + Link: ; rel="service-meta"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/rpc + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-desc"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/rpc/* + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-desc"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/ru/rpc + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-desc"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/ru/rpc/* + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-desc"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/api + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-desc"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/api/* + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-desc"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/ru/api + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-desc"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/ru/api/* + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-desc"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/neardata + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-desc"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/neardata/* + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-desc"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/ru/neardata + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-desc"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/ru/neardata/* + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-desc"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/agents + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-meta"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/agents/* + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-meta"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/ru/agents + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-meta"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/ru/agents/* + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-meta"; type="application/json" + Link: ; rel="service-meta"; type="application/json" + +/auth + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-meta"; type="application/json" + +/auth/* + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-meta"; type="application/json" + +/ru/auth + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-meta"; type="application/json" + +/ru/auth/* + Link: ; rel="api-catalog"; type="application/linkset+json" + Link: ; rel="service-meta"; type="application/json" + +/.well-known/api-catalog + Content-Type: application/linkset+json; charset=utf-8; profile="https://www.rfc-editor.org/info/rfc9727" + Link: ; rel="api-catalog"; type="application/linkset+json" + +/.well-known/agent-skills/index.json + Content-Type: application/json; charset=utf-8 + +/.well-known/agent-skills/*/SKILL.md + Content-Type: text/markdown; charset=utf-8 diff --git a/static/_worker.js b/static/_worker.js new file mode 100644 index 0000000..ead8a16 --- /dev/null +++ b/static/_worker.js @@ -0,0 +1,219 @@ +const MARKDOWN_CONTENT_TYPE = "text/markdown; charset=utf-8"; +const MARKDOWN_ACCEPT_TOKEN = "text/markdown"; +const AGENT_SKILLS_INDEX_PATH = "/.well-known/agent-skills/index.json"; +const API_CATALOG_LINK = '; rel="api-catalog"; type="application/linkset+json"'; +const FASTNEAR_OPENAPI_LINK = '; rel="service-desc"; type="application/json"'; +const NEARDATA_OPENAPI_LINK = '; rel="service-desc"; type="application/json"'; +const RPC_OPENAPI_LINK = + '; rel="service-desc"; type="application/json"'; +const SERVICE_META_JSON_TYPE = 'rel="service-meta"; type="application/json"'; + +function wantsMarkdown(request) { + const accept = request.headers.get("Accept") || ""; + return accept.toLowerCase().includes(MARKDOWN_ACCEPT_TOKEN); +} + +function appendVaryAccept(headers) { + const vary = headers.get("Vary"); + if (!vary) { + headers.set("Vary", "Accept"); + return; + } + + const parts = vary + .split(",") + .map((value) => value.trim()) + .filter(Boolean); + if (!parts.some((value) => value.toLowerCase() === "accept")) { + parts.push("Accept"); + headers.set("Vary", parts.join(", ")); + } +} + +function appendUniqueLink(headers, linkValue) { + const existing = headers.get("Link") || ""; + if (!existing.includes(linkValue)) { + headers.append("Link", linkValue); + } +} + +function isHtmlResponse(response) { + const contentType = response.headers.get("Content-Type") || ""; + return contentType.toLowerCase().includes("text/html"); +} + +function normalizePathname(pathname) { + if (!pathname || pathname === "/") { + return "/"; + } + + return pathname.endsWith("/") ? pathname.replace(/\/+$/, "") || "/" : pathname; +} + +function getLocalePrefix(pathname) { + return pathname === "/ru" || pathname.startsWith("/ru/") ? "/ru" : ""; +} + +function stripLocalePrefix(pathname) { + const localePrefix = getLocalePrefix(pathname); + if (!localePrefix) { + return pathname; + } + + const stripped = pathname.slice(localePrefix.length); + return stripped || "/"; +} + +function buildLocalizedSiteGraphPath(localePrefix) { + return localePrefix ? `${localePrefix}/structured-data/site-graph.json` : "/structured-data/site-graph.json"; +} + +function buildLocalizedAgentsPath(localePrefix) { + return localePrefix ? `${localePrefix}/agents` : "/agents"; +} + +function matchesRoute(pathname, baseRoute) { + return pathname === baseRoute || pathname.startsWith(`${baseRoute}/`); +} + +function getDiscoveryLinks(pathname) { + const normalizedPathname = normalizePathname(pathname); + const localePrefix = getLocalePrefix(normalizedPathname); + const strippedPathname = stripLocalePrefix(normalizedPathname); + const siteGraphLink = `<${buildLocalizedSiteGraphPath(localePrefix)}>; ${SERVICE_META_JSON_TYPE}`; + + if (normalizedPathname === "/.well-known/api-catalog") { + return [API_CATALOG_LINK]; + } + + if (strippedPathname === "/") { + return [ + API_CATALOG_LINK, + `<${buildLocalizedAgentsPath(localePrefix)}>; rel="service-doc"; type="text/html"`, + `<${AGENT_SKILLS_INDEX_PATH}>; ${SERVICE_META_JSON_TYPE}`, + siteGraphLink, + ]; + } + + if (matchesRoute(strippedPathname, "/rpc")) { + return [API_CATALOG_LINK, RPC_OPENAPI_LINK, siteGraphLink]; + } + + if (matchesRoute(strippedPathname, "/api")) { + return [API_CATALOG_LINK, FASTNEAR_OPENAPI_LINK, siteGraphLink]; + } + + if (matchesRoute(strippedPathname, "/neardata")) { + return [API_CATALOG_LINK, NEARDATA_OPENAPI_LINK, siteGraphLink]; + } + + if (matchesRoute(strippedPathname, "/agents")) { + return [ + API_CATALOG_LINK, + `<${AGENT_SKILLS_INDEX_PATH}>; ${SERVICE_META_JSON_TYPE}`, + siteGraphLink, + ]; + } + + if (matchesRoute(strippedPathname, "/auth")) { + return [API_CATALOG_LINK, siteGraphLink]; + } + + return []; +} + +function appendDiscoveryLinks(headers, pathname) { + for (const link of getDiscoveryLinks(pathname)) { + appendUniqueLink(headers, link); + } +} + +function resolveMarkdownPathname(pathname) { + if (!pathname || pathname.includes(".")) { + return null; + } + + if (pathname === "/") { + return "/index.md"; + } + + if (pathname === "/ru") { + return "/ru/index.md"; + } + + if (pathname.endsWith("/")) { + return `${pathname}index.md`; + } + + return `${pathname}.md`; +} + +function appendMarkdownAlternate(headers, markdownPathname) { + if (!markdownPathname) { + return; + } + + appendUniqueLink( + headers, + `<${markdownPathname}>; rel="alternate"; type="text/markdown"` + ); +} + +async function fetchAsset(request, env, pathname) { + const url = new URL(request.url); + url.pathname = pathname; + return env.ASSETS.fetch(new Request(url.toString(), request)); +} + +function cloneResponse(response, headers) { + return new Response(response.body, { + headers, + status: response.status, + statusText: response.statusText, + }); +} + +function finalizeHtmlResponse(response, pathname, markdownPathname) { + const headers = new Headers(response.headers); + appendVaryAccept(headers); + + if (response.status < 400 && isHtmlResponse(response)) { + appendDiscoveryLinks(headers, pathname); + appendMarkdownAlternate(headers, markdownPathname); + } + + return cloneResponse(response, headers); +} + +export default { + async fetch(request, env) { + const url = new URL(request.url); + const markdownPathname = resolveMarkdownPathname(url.pathname); + + if (!markdownPathname) { + return env.ASSETS.fetch(request); + } + + if (!wantsMarkdown(request)) { + const response = await env.ASSETS.fetch(request); + return finalizeHtmlResponse(response, url.pathname, markdownPathname); + } + + const markdownResponse = await fetchAsset(request, env, markdownPathname); + if (markdownResponse.status >= 400) { + const fallback = await env.ASSETS.fetch(request); + const headers = new Headers(fallback.headers); + appendVaryAccept(headers); + if (fallback.status < 400 && isHtmlResponse(fallback)) { + appendDiscoveryLinks(headers, url.pathname); + } + return cloneResponse(fallback, headers); + } + + const headers = new Headers(markdownResponse.headers); + headers.set("Content-Type", MARKDOWN_CONTENT_TYPE); + appendVaryAccept(headers); + appendDiscoveryLinks(headers, url.pathname); + return cloneResponse(markdownResponse, headers); + }, +}; diff --git a/static/openapi/fastnear.json b/static/openapi/fastnear.json new file mode 100644 index 0000000..8c85383 --- /dev/null +++ b/static/openapi/fastnear.json @@ -0,0 +1,1324 @@ +{ + "components": { + "schemas": { + "AccountBalanceRow": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "balance": { + "nullable": true, + "type": "string" + } + }, + "required": [ + "account_id", + "balance" + ], + "type": "object" + }, + "AccountFullResponse": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "nfts": { + "items": { + "$ref": "#/components/schemas/NftRow" + }, + "type": "array" + }, + "pools": { + "items": { + "$ref": "#/components/schemas/PoolRow" + }, + "type": "array" + }, + "state": { + "allOf": [ + { + "$ref": "#/components/schemas/AccountStateResponse" + } + ], + "nullable": true, + "type": "object" + }, + "tokens": { + "items": { + "$ref": "#/components/schemas/TokenRow" + }, + "type": "array" + } + }, + "required": [ + "account_id", + "pools", + "tokens", + "nfts", + "state" + ], + "type": "object" + }, + "AccountStateResponse": { + "additionalProperties": false, + "properties": { + "balance": { + "nullable": true, + "type": "string" + }, + "locked": { + "nullable": true, + "type": "string" + }, + "storage_bytes": { + "format": "uint64", + "minimum": 0, + "nullable": true, + "type": "integer" + } + }, + "required": [ + "balance", + "locked", + "storage_bytes" + ], + "type": "object" + }, + "HealthResponse": { + "additionalProperties": false, + "properties": { + "status": { + "type": "string" + } + }, + "required": [ + "status" + ], + "type": "object" + }, + "NftRow": { + "additionalProperties": false, + "properties": { + "contract_id": { + "type": "string" + }, + "last_update_block_height": { + "format": "uint64", + "minimum": 0, + "nullable": true, + "type": "integer" + } + }, + "required": [ + "contract_id", + "last_update_block_height" + ], + "type": "object" + }, + "PoolRow": { + "additionalProperties": false, + "properties": { + "last_update_block_height": { + "format": "uint64", + "minimum": 0, + "nullable": true, + "type": "integer" + }, + "pool_id": { + "type": "string" + } + }, + "required": [ + "pool_id", + "last_update_block_height" + ], + "type": "object" + }, + "PublicKeyLookupResponse": { + "additionalProperties": false, + "properties": { + "account_ids": { + "items": { + "type": "string" + }, + "type": "array" + }, + "public_key": { + "type": "string" + } + }, + "required": [ + "public_key", + "account_ids" + ], + "type": "object" + }, + "StatusResponse": { + "additionalProperties": false, + "properties": { + "sync_balance_block_height": { + "format": "uint64", + "minimum": 0, + "nullable": true, + "type": "integer" + }, + "sync_block_height": { + "format": "uint64", + "minimum": 0, + "nullable": true, + "type": "integer" + }, + "sync_block_timestamp_nanosec": { + "nullable": true, + "type": "string" + }, + "sync_latency_sec": { + "format": "double", + "nullable": true, + "type": "number" + }, + "version": { + "type": "string" + } + }, + "required": [ + "version", + "sync_block_height", + "sync_latency_sec", + "sync_block_timestamp_nanosec", + "sync_balance_block_height" + ], + "type": "object" + }, + "TokenAccountsResponse": { + "additionalProperties": false, + "properties": { + "accounts": { + "items": { + "$ref": "#/components/schemas/AccountBalanceRow" + }, + "type": "array" + }, + "token_id": { + "type": "string" + } + }, + "required": [ + "token_id", + "accounts" + ], + "type": "object" + }, + "TokenRow": { + "additionalProperties": false, + "properties": { + "balance": { + "nullable": true, + "type": "string" + }, + "contract_id": { + "type": "string" + }, + "last_update_block_height": { + "format": "uint64", + "minimum": 0, + "nullable": true, + "type": "integer" + } + }, + "required": [ + "contract_id", + "last_update_block_height", + "balance" + ], + "type": "object" + }, + "V0ContractsResponse": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "contract_ids": { + "items": { + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "account_id", + "contract_ids" + ], + "type": "object" + }, + "V0StakingResponse": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "pools": { + "items": { + "type": "string" + }, + "type": "array" + } + }, + "required": [ + "account_id", + "pools" + ], + "type": "object" + }, + "V1FtResponse": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "tokens": { + "items": { + "$ref": "#/components/schemas/TokenRow" + }, + "type": "array" + } + }, + "required": [ + "account_id", + "tokens" + ], + "type": "object" + }, + "V1NftResponse": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "tokens": { + "items": { + "$ref": "#/components/schemas/NftRow" + }, + "type": "array" + } + }, + "required": [ + "account_id", + "tokens" + ], + "type": "object" + }, + "V1StakingResponse": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "pools": { + "items": { + "$ref": "#/components/schemas/PoolRow" + }, + "type": "array" + } + }, + "required": [ + "account_id", + "pools" + ], + "type": "object" + } + } + }, + "info": { + "description": "Low-latency indexed account, token, and public-key lookup APIs for wallets and explorers. Embedded portal clients may forward an optional `apiKey` query parameter, but the public FastNEAR API does not require it.", + "title": "FastNEAR API", + "version": "3.0.3" + }, + "openapi": "3.0.3", + "paths": { + "/health": { + "get": { + "description": "Ping the FastNEAR API for liveness — returns `{status: ok}` when healthy.", + "operationId": "get_health", + "parameters": [ + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "status": "ok" + }, + "schema": { + "$ref": "#/components/schemas/HealthResponse" + } + } + }, + "description": "Health status string" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Get service health", + "tags": [ + "system" + ], + "x-fastnear-slug": "health", + "x-fastnear-title": "FastNEAR API - Health" + } + }, + "/status": { + "get": { + "description": "Check the current indexed block height, latency, and deployed service version.", + "operationId": "get_status", + "parameters": [ + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "sync_balance_block_height": 129734103, + "sync_block_height": 129734103, + "sync_block_timestamp_nanosec": "1728256282197171397", + "sync_latency_sec": 4.671730603, + "version": "0.10.0" + }, + "schema": { + "$ref": "#/components/schemas/StatusResponse" + } + } + }, + "description": "Current FastNEAR API sync status" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Get service sync status", + "tags": [ + "system" + ], + "x-fastnear-slug": "status", + "x-fastnear-title": "FastNEAR API - Status" + } + }, + "/v0/account/{account_id}/ft": { + "get": { + "description": "Fetch the fungible token contract IDs an account has held — contract IDs only, no balances.", + "operationId": "account_ft_v0", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "here.tg", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "here.tg", + "contract_ids": [ + "wrap.near", + "usdt.tether-token.near" + ] + }, + "schema": { + "$ref": "#/components/schemas/V0ContractsResponse" + } + } + }, + "description": "Fungible token contract IDs for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup fungible token contract IDs for an account", + "tags": [ + "fungible-tokens" + ], + "x-fastnear-slug": "account_ft", + "x-fastnear-title": "FastNEAR API - V0 Account FT" + } + }, + "/v0/account/{account_id}/nft": { + "get": { + "description": "Fetch the NFT contract IDs an account has held — contract IDs only, no block-height metadata.", + "operationId": "account_nft_v0", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "sharddog.near", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "sharddog.near", + "contract_ids": [ + "nft.example.near" + ] + }, + "schema": { + "$ref": "#/components/schemas/V0ContractsResponse" + } + } + }, + "description": "NFT contract IDs for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup NFT contract IDs for an account", + "tags": [ + "non-fungible-tokens" + ], + "x-fastnear-slug": "account_nft", + "x-fastnear-title": "FastNEAR API - V0 Account NFT" + } + }, + "/v0/account/{account_id}/staking": { + "get": { + "description": "Fetch staking pool account IDs for one account — pool IDs only, no block-height metadata.", + "operationId": "account_staking_v0", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "mob.near", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "mob.near", + "pools": [ + "zavodil.poolv1.near" + ] + }, + "schema": { + "$ref": "#/components/schemas/V0StakingResponse" + } + } + }, + "description": "Staking pool account IDs for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup staking pool account IDs for an account", + "tags": [ + "staking" + ], + "x-fastnear-slug": "account_staking", + "x-fastnear-title": "FastNEAR API - V0 Account Staking" + } + }, + "/v0/public_key/{public_key}": { + "get": { + "description": "Fetch the account IDs that have registered a full-access public key, via the legacy V0 lookup path.", + "operationId": "lookup_by_public_key_v0", + "parameters": [ + { + "description": "NEAR public key in `ed25519:...` or `secp256k1:...` form.", + "example": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT", + "in": "path", + "name": "public_key", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_ids": [ + "root.near" + ], + "public_key": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT" + }, + "schema": { + "$ref": "#/components/schemas/PublicKeyLookupResponse" + } + } + }, + "description": "Matching account IDs for the supplied full-access public key" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup full-access accounts by public key", + "tags": [ + "public-key" + ], + "x-fastnear-slug": "public_key_lookup", + "x-fastnear-title": "FastNEAR API - V0 Public Key Lookup" + } + }, + "/v0/public_key/{public_key}/all": { + "get": { + "description": "List every account tied to a public key — full-access and limited-access keys together — via the legacy V0 lookup-all path.", + "operationId": "lookup_by_public_key_all_v0", + "parameters": [ + { + "description": "NEAR public key in `ed25519:...` or `secp256k1:...` form.", + "example": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT", + "in": "path", + "name": "public_key", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_ids": [ + "root.near" + ], + "public_key": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT" + }, + "schema": { + "$ref": "#/components/schemas/PublicKeyLookupResponse" + } + } + }, + "description": "Matching account IDs for the supplied public key, including limited-access keys" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup all indexed accounts by public key", + "tags": [ + "public-key" + ], + "x-fastnear-slug": "public_key_lookup_all", + "x-fastnear-title": "FastNEAR API - V0 Public Key Lookup (All)" + } + }, + "/v1/account/{account_id}/ft": { + "get": { + "description": "Fetch an account's fungible token balance rows, each with contract ID, balance, and last-update block height.", + "operationId": "account_ft_v1", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "here.tg", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "here.tg", + "tokens": [ + { + "balance": "1000000000000000000000000", + "contract_id": "wrap.near", + "last_update_block_height": null + } + ] + }, + "schema": { + "$ref": "#/components/schemas/V1FtResponse" + } + } + }, + "description": "Indexed fungible token rows for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup indexed fungible token rows for an account", + "tags": [ + "fungible-tokens" + ], + "x-fastnear-slug": "account_ft", + "x-fastnear-title": "FastNEAR API - V1 Account FT" + } + }, + "/v1/account/{account_id}/full": { + "get": { + "description": "Fetch the combined indexed account view, including staking pools, FT balances, NFTs, and account state.", + "operationId": "account_full_v1", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "here.tg", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "here.tg", + "nfts": [], + "pools": [], + "state": { + "balance": "1000000000000000000000000", + "locked": "0", + "storage_bytes": 512 + }, + "tokens": [] + }, + "schema": { + "$ref": "#/components/schemas/AccountFullResponse" + } + } + }, + "description": "Full indexed account information for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup full indexed account information", + "tags": [ + "accounts" + ], + "x-fastnear-slug": "account_full", + "x-fastnear-title": "FastNEAR API - V1 Account Full" + } + }, + "/v1/account/{account_id}/nft": { + "get": { + "description": "Fetch NFT contract rows for an account, including block-height metadata for each contract.", + "operationId": "account_nft_v1", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "sharddog.near", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "sharddog.near", + "tokens": [ + { + "contract_id": "nft.example.near", + "last_update_block_height": null + } + ] + }, + "schema": { + "$ref": "#/components/schemas/V1NftResponse" + } + } + }, + "description": "Indexed NFT contract rows for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup indexed NFT contract rows for an account", + "tags": [ + "non-fungible-tokens" + ], + "x-fastnear-slug": "account_nft", + "x-fastnear-title": "FastNEAR API - V1 Account NFT" + } + }, + "/v1/account/{account_id}/staking": { + "get": { + "description": "Retrieve staking pool rows for an account, including block-height metadata for each pool relationship.", + "operationId": "account_staking_v1", + "parameters": [ + { + "description": "NEAR account ID to inspect.", + "example": "mob.near", + "in": "path", + "name": "account_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_id": "mob.near", + "pools": [ + { + "last_update_block_height": null, + "pool_id": "zavodil.poolv1.near" + } + ] + }, + "schema": { + "$ref": "#/components/schemas/V1StakingResponse" + } + } + }, + "description": "Indexed staking pool rows for the requested account" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup indexed staking pools for an account", + "tags": [ + "staking" + ], + "x-fastnear-slug": "account_staking", + "x-fastnear-title": "FastNEAR API - V1 Account Staking" + } + }, + "/v1/ft/{token_id}/top": { + "get": { + "description": "Fetch the top-balance holder list for a fungible token contract, ranked highest balance first.", + "operationId": "ft_top_v1", + "parameters": [ + { + "description": "Fungible token contract account ID.", + "example": "wrap.near", + "in": "path", + "name": "token_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "accounts": [ + { + "account_id": "mob.near", + "balance": "979894691374420631019486155" + } + ], + "token_id": "wrap.near" + }, + "schema": { + "$ref": "#/components/schemas/TokenAccountsResponse" + } + } + }, + "description": "Indexed top holders for the requested fungible token" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup top indexed holders for a fungible token", + "tags": [ + "fungible-tokens" + ], + "x-fastnear-slug": "ft_top", + "x-fastnear-title": "FastNEAR API - V1 FT Top Holders" + } + }, + "/v1/public_key/{public_key}": { + "get": { + "description": "Resolve a full-access public key to the indexed NEAR accounts that have registered it — V1 canonical lookup path.", + "operationId": "lookup_by_public_key_v1", + "parameters": [ + { + "description": "NEAR public key in `ed25519:...` or `secp256k1:...` form.", + "example": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT", + "in": "path", + "name": "public_key", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_ids": [ + "root.near" + ], + "public_key": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT" + }, + "schema": { + "$ref": "#/components/schemas/PublicKeyLookupResponse" + } + } + }, + "description": "Matching account IDs for the supplied full-access public key" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup full-access accounts by public key", + "tags": [ + "public-key" + ], + "x-fastnear-slug": "public_key_lookup", + "x-fastnear-title": "FastNEAR API - V1 Public Key Lookup" + } + }, + "/v1/public_key/{public_key}/all": { + "get": { + "description": "Resolve a public key to every account that holds it — full-access and limited-access keys alike — via the V1 lookup-all path.", + "operationId": "lookup_by_public_key_all_v1", + "parameters": [ + { + "description": "NEAR public key in `ed25519:...` or `secp256k1:...` form.", + "example": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT", + "in": "path", + "name": "public_key", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional API key forwarded by embedded portal clients. The public FastNEAR API does not require it.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "account_ids": [ + "root.near" + ], + "public_key": "ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT" + }, + "schema": { + "$ref": "#/components/schemas/PublicKeyLookupResponse" + } + } + }, + "description": "Matching account IDs for the supplied public key, including limited-access keys" + }, + "400": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Bad Request" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Internal Server Error" + } + }, + "summary": "Lookup all indexed accounts by public key", + "tags": [ + "public-key" + ], + "x-fastnear-slug": "public_key_lookup_all", + "x-fastnear-title": "FastNEAR API - V1 Public Key Lookup (All)" + } + } + }, + "servers": [ + { + "description": "Mainnet", + "url": "https://api.fastnear.com" + }, + { + "description": "Testnet", + "url": "https://test.api.fastnear.com" + } + ] +} diff --git a/static/openapi/neardata.json b/static/openapi/neardata.json new file mode 100644 index 0000000..46f72f0 --- /dev/null +++ b/static/openapi/neardata.json @@ -0,0 +1,1536 @@ +{ + "components": { + "schemas": { + "ActionDocument": { + "additionalProperties": true, + "type": "object" + }, + "ActionReceiptBody": { + "additionalProperties": false, + "properties": { + "Action": { + "$ref": "#/components/schemas/ActionReceiptDocument" + } + }, + "required": [ + "Action" + ], + "type": "object" + }, + "ActionReceiptDocument": { + "additionalProperties": false, + "properties": { + "actions": { + "items": { + "$ref": "#/components/schemas/ActionDocument" + }, + "type": "array" + }, + "gas_price": { + "type": "string" + }, + "input_data_ids": { + "items": { + "type": "string" + }, + "type": "array" + }, + "is_promise_yield": { + "type": "boolean" + }, + "output_data_receivers": { + "items": { + "$ref": "#/components/schemas/OutputDataReceiverDocument" + }, + "type": "array" + }, + "signer_id": { + "type": "string" + }, + "signer_public_key": { + "type": "string" + } + }, + "required": [ + "actions", + "gas_price", + "input_data_ids", + "is_promise_yield", + "output_data_receivers", + "signer_id", + "signer_public_key" + ], + "type": "object" + }, + "BlockDocument": { + "additionalProperties": false, + "description": "Full block document as served by neardata, including the block envelope and per-shard payloads.", + "properties": { + "block": { + "$ref": "#/components/schemas/BlockEnvelope" + }, + "shards": { + "items": { + "$ref": "#/components/schemas/ShardDocument" + }, + "type": "array" + } + }, + "required": [ + "block", + "shards" + ], + "type": "object" + }, + "BlockEnvelope": { + "additionalProperties": false, + "description": "Block-level payload returned by neardata.", + "properties": { + "author": { + "description": "Block producer account ID.", + "type": "string" + }, + "chunks": { + "items": { + "$ref": "#/components/schemas/ChunkHeader" + }, + "type": "array" + }, + "header": { + "$ref": "#/components/schemas/BlockHeader" + } + }, + "required": [ + "author", + "chunks", + "header" + ], + "type": "object" + }, + "BlockErrorResponse": { + "additionalProperties": false, + "properties": { + "error": { + "type": "string" + }, + "type": { + "$ref": "#/components/schemas/BlockErrorType" + } + }, + "required": [ + "error", + "type" + ], + "type": "object" + }, + "BlockErrorType": { + "enum": [ + "BLOCK_HEIGHT_TOO_HIGH", + "BLOCK_HEIGHT_TOO_LOW", + "BLOCK_DOES_NOT_EXIST" + ], + "type": "string" + }, + "BlockHeader": { + "additionalProperties": true, + "description": "Block header object as served by neardata.", + "properties": { + "chunks_included": { + "format": "uint64", + "type": "integer" + }, + "epoch_id": { + "type": "string" + }, + "gas_price": { + "type": "string" + }, + "hash": { + "type": "string" + }, + "height": { + "format": "uint64", + "type": "integer" + }, + "next_epoch_id": { + "type": "string" + }, + "prev_hash": { + "type": "string" + }, + "prev_height": { + "format": "uint64", + "type": "integer" + }, + "timestamp": { + "type": "integer" + }, + "timestamp_nanosec": { + "type": "string" + }, + "total_supply": { + "type": "string" + } + }, + "type": "object" + }, + "ChunkDocument": { + "additionalProperties": false, + "description": "Chunk payload returned by neardata for a single shard in a selected block.", + "properties": { + "author": { + "description": "Chunk producer account ID.", + "type": "string" + }, + "header": { + "$ref": "#/components/schemas/ChunkHeader" + }, + "receipts": { + "items": { + "$ref": "#/components/schemas/ReceiptDocument" + }, + "type": "array" + }, + "transactions": { + "items": { + "$ref": "#/components/schemas/ChunkTransactionWrapper" + }, + "type": "array" + } + }, + "required": [ + "author", + "header", + "receipts", + "transactions" + ], + "type": "object" + }, + "ChunkHeader": { + "additionalProperties": true, + "description": "Chunk header object as served by neardata.", + "properties": { + "chunk_hash": { + "type": "string" + }, + "gas_limit": { + "type": "integer" + }, + "gas_used": { + "type": "integer" + }, + "height_created": { + "format": "uint64", + "type": "integer" + }, + "height_included": { + "format": "uint64", + "type": "integer" + }, + "outcome_root": { + "type": "string" + }, + "outgoing_receipts_root": { + "type": "string" + }, + "prev_block_hash": { + "type": "string" + }, + "shard_id": { + "format": "uint64", + "type": "integer" + }, + "tx_root": { + "type": "string" + } + }, + "type": "object" + }, + "ChunkTransactionWrapper": { + "additionalProperties": false, + "description": "Transaction entry returned inside a neardata chunk.", + "properties": { + "outcome": { + "$ref": "#/components/schemas/ExecutionWithReceipt" + }, + "transaction": { + "$ref": "#/components/schemas/SignedTransactionDocument" + } + }, + "required": [ + "outcome", + "transaction" + ], + "type": "object" + }, + "DataReceiptBody": { + "additionalProperties": false, + "properties": { + "Data": { + "$ref": "#/components/schemas/DataReceiptDocument" + } + }, + "required": [ + "Data" + ], + "type": "object" + }, + "DataReceiptDocument": { + "additionalProperties": false, + "properties": { + "data": { + "type": "string" + }, + "data_id": { + "type": "string" + }, + "is_promise_resume": { + "type": "boolean" + } + }, + "required": [ + "data", + "data_id", + "is_promise_resume" + ], + "type": "object" + }, + "ExecutionOutcomeDocument": { + "additionalProperties": false, + "properties": { + "block_hash": { + "type": "string" + }, + "id": { + "type": "string" + }, + "outcome": { + "$ref": "#/components/schemas/ExecutionOutcomeSummary" + }, + "proof": { + "items": { + "$ref": "#/components/schemas/ExecutionProofItem" + }, + "type": "array" + } + }, + "required": [ + "block_hash", + "id", + "outcome", + "proof" + ], + "type": "object" + }, + "ExecutionOutcomeStatus": { + "oneOf": [ + { + "$ref": "#/components/schemas/ExecutionOutcomeStatusSuccessReceiptId" + }, + { + "$ref": "#/components/schemas/ExecutionOutcomeStatusSuccessValue" + }, + { + "$ref": "#/components/schemas/ExecutionOutcomeStatusFailure" + } + ] + }, + "ExecutionOutcomeStatusFailure": { + "additionalProperties": false, + "properties": { + "Failure": { + "additionalProperties": true, + "type": "object" + } + }, + "required": [ + "Failure" + ], + "type": "object" + }, + "ExecutionOutcomeStatusSuccessReceiptId": { + "additionalProperties": false, + "properties": { + "SuccessReceiptId": { + "type": "string" + } + }, + "required": [ + "SuccessReceiptId" + ], + "type": "object" + }, + "ExecutionOutcomeStatusSuccessValue": { + "additionalProperties": false, + "properties": { + "SuccessValue": { + "type": "string" + } + }, + "required": [ + "SuccessValue" + ], + "type": "object" + }, + "ExecutionOutcomeSummary": { + "additionalProperties": false, + "properties": { + "executor_id": { + "type": "string" + }, + "gas_burnt": { + "format": "uint64", + "type": "integer" + }, + "logs": { + "items": { + "type": "string" + }, + "type": "array" + }, + "metadata": { + "additionalProperties": true, + "type": "object" + }, + "receipt_ids": { + "items": { + "type": "string" + }, + "type": "array" + }, + "status": { + "$ref": "#/components/schemas/ExecutionOutcomeStatus" + }, + "tokens_burnt": { + "type": "string" + } + }, + "required": [ + "executor_id", + "gas_burnt", + "logs", + "metadata", + "receipt_ids", + "status", + "tokens_burnt" + ], + "type": "object" + }, + "ExecutionProofItem": { + "additionalProperties": true, + "type": "object" + }, + "ExecutionWithReceipt": { + "additionalProperties": false, + "description": "Execution result paired with an optional receipt object.", + "properties": { + "execution_outcome": { + "$ref": "#/components/schemas/ExecutionOutcomeDocument" + }, + "receipt": { + "description": "Receipt payload when neardata includes it for this entry.", + "nullable": true, + "oneOf": [ + { + "$ref": "#/components/schemas/ReceiptDocument" + }, + { + "$ref": "#/components/schemas/OmittedReceiptDocument" + } + ], + "type": "object" + }, + "tx_hash": { + "type": "string" + } + }, + "required": [ + "execution_outcome", + "receipt" + ], + "type": "object" + }, + "HealthResponse": { + "additionalProperties": false, + "properties": { + "status": { + "type": "string" + } + }, + "required": [ + "status" + ], + "type": "object" + }, + "OmittedReceiptDocument": { + "additionalProperties": false, + "type": "object" + }, + "OutputDataReceiverDocument": { + "additionalProperties": false, + "properties": { + "data_id": { + "type": "string" + }, + "receiver_id": { + "type": "string" + } + }, + "required": [ + "data_id", + "receiver_id" + ], + "type": "object" + }, + "ReceiptBody": { + "oneOf": [ + { + "$ref": "#/components/schemas/ActionReceiptBody" + }, + { + "$ref": "#/components/schemas/DataReceiptBody" + } + ] + }, + "ReceiptDocument": { + "additionalProperties": false, + "description": "Receipt object as served by neardata inside a chunk payload.", + "properties": { + "predecessor_id": { + "type": "string" + }, + "priority": { + "format": "uint64", + "type": "integer" + }, + "receipt": { + "$ref": "#/components/schemas/ReceiptBody" + }, + "receipt_id": { + "type": "string" + }, + "receiver_id": { + "type": "string" + } + }, + "required": [ + "predecessor_id", + "priority", + "receipt", + "receipt_id", + "receiver_id" + ], + "type": "object" + }, + "ShardDocument": { + "additionalProperties": false, + "description": "Per-shard payload returned by neardata for a block.", + "properties": { + "chunk": { + "$ref": "#/components/schemas/ChunkDocument" + }, + "receipt_execution_outcomes": { + "items": { + "$ref": "#/components/schemas/ExecutionWithReceipt" + }, + "type": "array" + }, + "shard_id": { + "format": "uint64", + "type": "integer" + }, + "state_changes": { + "items": { + "$ref": "#/components/schemas/StateChangeItem" + }, + "type": "array" + } + }, + "required": [ + "chunk", + "receipt_execution_outcomes", + "shard_id", + "state_changes" + ], + "type": "object" + }, + "SignedTransactionDocument": { + "additionalProperties": false, + "properties": { + "actions": { + "items": { + "$ref": "#/components/schemas/ActionDocument" + }, + "type": "array" + }, + "hash": { + "type": "string" + }, + "nonce": { + "format": "uint64", + "type": "integer" + }, + "priority_fee": { + "format": "uint64", + "type": "integer" + }, + "public_key": { + "type": "string" + }, + "receiver_id": { + "type": "string" + }, + "signature": { + "type": "string" + }, + "signer_id": { + "type": "string" + } + }, + "required": [ + "actions", + "hash", + "nonce", + "priority_fee", + "public_key", + "receiver_id", + "signature", + "signer_id" + ], + "type": "object" + }, + "StateChangeCause": { + "oneOf": [ + { + "$ref": "#/components/schemas/StateChangeCauseTransactionProcessing" + }, + { + "$ref": "#/components/schemas/StateChangeCauseReceiptProcessing" + }, + { + "$ref": "#/components/schemas/StateChangeCauseActionReceiptGasReward" + } + ] + }, + "StateChangeCauseActionReceiptGasReward": { + "additionalProperties": false, + "properties": { + "receipt_hash": { + "type": "string" + }, + "type": { + "type": "string" + } + }, + "required": [ + "receipt_hash", + "type" + ], + "type": "object" + }, + "StateChangeCauseReceiptProcessing": { + "additionalProperties": false, + "properties": { + "receipt_hash": { + "type": "string" + }, + "type": { + "type": "string" + } + }, + "required": [ + "receipt_hash", + "type" + ], + "type": "object" + }, + "StateChangeCauseTransactionProcessing": { + "additionalProperties": false, + "properties": { + "tx_hash": { + "type": "string" + }, + "type": { + "type": "string" + } + }, + "required": [ + "tx_hash", + "type" + ], + "type": "object" + }, + "StateChangeItem": { + "additionalProperties": false, + "description": "State change entry returned by neardata for a shard.", + "properties": { + "cause": { + "$ref": "#/components/schemas/StateChangeCause" + }, + "change": { + "$ref": "#/components/schemas/StateChangeValue" + }, + "type": { + "type": "string" + } + }, + "required": [ + "cause", + "change", + "type" + ], + "type": "object" + }, + "StateChangeValue": { + "oneOf": [ + { + "$ref": "#/components/schemas/StateChangeValueAccountUpdate" + }, + { + "$ref": "#/components/schemas/StateChangeValueAccessKeyUpdate" + }, + { + "$ref": "#/components/schemas/StateChangeValueDataUpdate" + }, + { + "$ref": "#/components/schemas/StateChangeValueDataDeletion" + } + ] + }, + "StateChangeValueAccessKeyUpdate": { + "additionalProperties": false, + "properties": { + "access_key": { + "additionalProperties": true, + "type": "object" + }, + "account_id": { + "type": "string" + }, + "public_key": { + "type": "string" + } + }, + "required": [ + "access_key", + "account_id", + "public_key" + ], + "type": "object" + }, + "StateChangeValueAccountUpdate": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "amount": { + "type": "string" + }, + "code_hash": { + "type": "string" + }, + "locked": { + "type": "string" + }, + "storage_paid_at": { + "format": "uint64", + "type": "integer" + }, + "storage_usage": { + "format": "uint64", + "type": "integer" + } + }, + "required": [ + "account_id", + "amount", + "code_hash", + "locked", + "storage_paid_at", + "storage_usage" + ], + "type": "object" + }, + "StateChangeValueDataDeletion": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "key_base64": { + "type": "string" + } + }, + "required": [ + "account_id", + "key_base64" + ], + "type": "object" + }, + "StateChangeValueDataUpdate": { + "additionalProperties": false, + "properties": { + "account_id": { + "type": "string" + }, + "key_base64": { + "type": "string" + }, + "value_base64": { + "type": "string" + } + }, + "required": [ + "account_id", + "key_base64", + "value_base64" + ], + "type": "object" + } + } + }, + "info": { + "description": "Cached and archived NEAR block data with redirect helpers for first-block and latest-block workflows. Some block-family routes may redirect depending on archive or freshness topology.", + "title": "NEAR Data API", + "version": "3.0.3" + }, + "openapi": "3.0.3", + "paths": { + "/health": { + "get": { + "description": "Ping the neardata service for liveness — returns `{status: ok}` when healthy, errors otherwise.", + "operationId": "get_health", + "parameters": [ + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "example": { + "status": "ok" + }, + "schema": { + "$ref": "#/components/schemas/HealthResponse" + } + } + }, + "description": "Health payload" + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Get service health", + "tags": [ + "system" + ], + "x-fastnear-slug": "health", + "x-fastnear-title": "NEAR Data API - Health" + } + }, + "/v0/block/{block_height}": { + "get": { + "description": "Fetch a finalized block's full document at a chosen height — header plus every chunk and shard payload.", + "operationId": "get_block", + "parameters": [ + { + "description": "NEAR block height to retrieve.", + "example": "50000000", + "in": "path", + "name": "block_height", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDocument", + "nullable": true + } + } + }, + "description": "Requested document, or `null` when the selected slice is absent" + }, + "302": { + "description": "Redirect to a canonical archive or finalized block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "404": { + "content": { + "application/json": { + "example": { + "error": "The block does not exist in this archive range", + "type": "BLOCK_DOES_NOT_EXIST" + }, + "schema": { + "$ref": "#/components/schemas/BlockErrorResponse" + } + } + }, + "description": "Structured block-height error" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Fetch a finalized block by height", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "block", + "x-fastnear-title": "NEAR Data API - Block" + } + }, + "/v0/block/{block_height}/chunk/{shard_id}": { + "get": { + "description": "Fetch one chunk — a single shard's transactions and incoming receipts — at a chosen block height.", + "operationId": "get_chunk", + "parameters": [ + { + "description": "NEAR block height to retrieve.", + "example": "50000000", + "in": "path", + "name": "block_height", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Shard ID whose chunk should be returned.", + "example": "0", + "in": "path", + "name": "shard_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ChunkDocument", + "nullable": true + } + } + }, + "description": "Requested document, or `null` when the selected slice is absent" + }, + "302": { + "description": "Redirect to a canonical archive or finalized block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "404": { + "content": { + "application/json": { + "example": { + "error": "The block does not exist in this archive range", + "type": "BLOCK_DOES_NOT_EXIST" + }, + "schema": { + "$ref": "#/components/schemas/BlockErrorResponse" + } + } + }, + "description": "Structured block-height error" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Fetch one chunk from a finalized block", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "block_chunk", + "x-fastnear-title": "NEAR Data API - Block Chunk" + } + }, + "/v0/block/{block_height}/headers": { + "get": { + "description": "Fetch only a finalized block's header and chunk summaries — no per-shard payload.", + "operationId": "get_block_headers", + "parameters": [ + { + "description": "NEAR block height to retrieve.", + "example": "50000000", + "in": "path", + "name": "block_height", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockEnvelope", + "nullable": true + } + } + }, + "description": "Requested document, or `null` when the selected slice is absent" + }, + "302": { + "description": "Redirect to a canonical archive or finalized block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "404": { + "content": { + "application/json": { + "example": { + "error": "The block does not exist in this archive range", + "type": "BLOCK_DOES_NOT_EXIST" + }, + "schema": { + "$ref": "#/components/schemas/BlockErrorResponse" + } + } + }, + "description": "Structured block-height error" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Fetch the block-level object for a finalized block", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "block_headers", + "x-fastnear-title": "NEAR Data API - Block Headers" + } + }, + "/v0/block/{block_height}/shard/{shard_id}": { + "get": { + "description": "Fetch one shard's full payload at a chosen block — chunk plus state changes and produced receipts.", + "operationId": "get_shard", + "parameters": [ + { + "description": "NEAR block height to retrieve.", + "example": "50000000", + "in": "path", + "name": "block_height", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Shard ID to return.", + "example": "0", + "in": "path", + "name": "shard_id", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/ShardDocument", + "nullable": true + } + } + }, + "description": "Requested document, or `null` when the selected slice is absent" + }, + "302": { + "description": "Redirect to a canonical archive or finalized block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "404": { + "content": { + "application/json": { + "example": { + "error": "The block does not exist in this archive range", + "type": "BLOCK_DOES_NOT_EXIST" + }, + "schema": { + "$ref": "#/components/schemas/BlockErrorResponse" + } + } + }, + "description": "Structured block-height error" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Fetch one shard from a finalized block", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "block_shard", + "x-fastnear-title": "NEAR Data API - Block Shard" + } + }, + "/v0/block_opt/{block_height}": { + "get": { + "description": "Fetch an optimistic (not-yet-final) block at a chosen height — may redirect once the optimistic window has finalized.", + "operationId": "get_block_optimistic", + "parameters": [ + { + "description": "NEAR block height to retrieve.", + "example": "50000000", + "in": "path", + "name": "block_height", + "required": true, + "schema": { + "type": "string" + } + }, + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDocument", + "nullable": true + } + } + }, + "description": "Requested document, or `null` when the selected slice is absent" + }, + "302": { + "description": "Redirect to a canonical archive or finalized block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "404": { + "content": { + "application/json": { + "example": { + "error": "The block does not exist in this archive range", + "type": "BLOCK_DOES_NOT_EXIST" + }, + "schema": { + "$ref": "#/components/schemas/BlockErrorResponse" + } + } + }, + "description": "Structured block-height error" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Fetch an optimistic block by height", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "block_optimistic", + "x-fastnear-title": "NEAR Data API - Optimistic Block" + } + }, + "/v0/first_block": { + "get": { + "description": "Redirect to the chain's first post-genesis block — a starting cursor for indexers backfilling from the beginning.", + "operationId": "get_first_block", + "parameters": [ + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDocument", + "nullable": true + } + } + }, + "description": "Full block document returned after automatic redirect following" + }, + "302": { + "description": "Redirect to the canonical first block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + } + }, + "summary": "Redirect to the first block after genesis", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "first_block", + "x-fastnear-title": "NEAR Data API - First Block" + } + }, + "/v0/last_block/final": { + "get": { + "description": "Redirect to the most recent finalized block — the chain-tip cursor once consensus has settled.", + "operationId": "get_last_block_final", + "parameters": [ + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDocument", + "nullable": true + } + } + }, + "description": "Full block document returned after automatic redirect following" + }, + "302": { + "description": "Redirect to the latest block block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Redirect to the latest finalized block", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "last_block_final", + "x-fastnear-title": "NEAR Data API - Last Final Block" + } + }, + "/v0/last_block/optimistic": { + "get": { + "description": "Redirect to the most recent optimistic block — the freshest-possible tip, ahead of final settlement.", + "operationId": "get_last_block_optimistic", + "parameters": [ + { + "description": "Optional FastNEAR subscription API key. Invalid values may return `401` before redirect handling.", + "in": "query", + "name": "apiKey", + "required": false, + "schema": { + "type": "string" + } + } + ], + "responses": { + "200": { + "content": { + "application/json": { + "schema": { + "$ref": "#/components/schemas/BlockDocument", + "nullable": true + } + } + }, + "description": "Full block document returned after automatic redirect following" + }, + "302": { + "description": "Redirect to the latest block block URL", + "headers": { + "Location": { + "schema": { + "type": "string" + } + } + } + }, + "401": { + "content": { + "text/plain": { + "example": "Unauthorized", + "schema": { + "type": "string" + } + } + }, + "description": "Invalid or unauthorized API key" + }, + "500": { + "content": { + "application/json": { + "schema": { + "type": "string" + } + } + }, + "description": "Cache or internal data error" + } + }, + "summary": "Redirect to the latest optimistic block", + "tags": [ + "blocks" + ], + "x-fastnear-slug": "last_block_optimistic", + "x-fastnear-title": "NEAR Data API - Last Optimistic Block" + } + } + }, + "servers": [ + { + "description": "Mainnet", + "url": "https://mainnet.neardata.xyz" + }, + { + "description": "Testnet", + "url": "https://testnet.neardata.xyz" + } + ] +} diff --git a/static/robots.txt b/static/robots.txt index 0b2008f..4b564e8 100644 --- a/static/robots.txt +++ b/static/robots.txt @@ -1,5 +1,6 @@ User-agent: * Allow: / +Content-Signal: search=yes, ai-input=yes, ai-train=yes User-agent: GPTBot Allow: / diff --git a/static/ru/agents.md b/static/ru/agents.md index 41f6435..3c65213 100644 --- a/static/ru/agents.md +++ b/static/ru/agents.md @@ -2,8 +2,6 @@ # Агенты на FastNear -{/* FASTNEAR_AI_DISCOVERY: Это операционная точка входа для ИИ-агентов, краулеров и сред автоматизации. Страница объясняет, какую информацию собрать до первого запроса, с какого API FastNear начинать, как устроена аутентификация между API и что должен содержать полезный ответ агента. */} - Эта страница — операционная точка входа для ИИ-агентов, краулеров и сред автоматизации, использующих FastNear. Цель простая: распознать реальную задачу пользователя, выбрать один API FastNear, получить минимальный полезный результат и расширяться на другой API только тогда, когда явно не хватает части ответа. ## Если нужен только следующий шаг diff --git a/static/ru/agents/choosing-surfaces.md b/static/ru/agents/choosing-surfaces.md index 0e21fa4..470756a 100644 --- a/static/ru/agents/choosing-surfaces.md +++ b/static/ru/agents/choosing-surfaces.md @@ -2,8 +2,6 @@ # Как выбрать подходящую поверхность -{/* FASTNEAR_AI_DISCOVERY: Эта страница — для ИИ-агентов, которые выбирают поверхность FastNear по намерению пользователя. Она объясняет, как перейти от цели пользователя к лучшей первой поверхности, когда комбинировать поверхности и каких типичных ошибок избегать. */} - Не начинайте с того, чтобы отдавать агенту каждый эндпоинт FastNear. Сначала сформулируйте, какую задачу на самом деле хочет решить пользователь, а затем выберите один API или раздел справочника FastNear, который наиболее прямо отвечает на эту задачу. Для агента важнее не вопрос «какой эндпоинт существует?», а вопрос «какой ответ поможет пользователю сделать следующий шаг?». diff --git a/static/ru/agents/choosing-surfaces/index.md b/static/ru/agents/choosing-surfaces/index.md index 0e21fa4..470756a 100644 --- a/static/ru/agents/choosing-surfaces/index.md +++ b/static/ru/agents/choosing-surfaces/index.md @@ -2,8 +2,6 @@ # Как выбрать подходящую поверхность -{/* FASTNEAR_AI_DISCOVERY: Эта страница — для ИИ-агентов, которые выбирают поверхность FastNear по намерению пользователя. Она объясняет, как перейти от цели пользователя к лучшей первой поверхности, когда комбинировать поверхности и каких типичных ошибок избегать. */} - Не начинайте с того, чтобы отдавать агенту каждый эндпоинт FastNear. Сначала сформулируйте, какую задачу на самом деле хочет решить пользователь, а затем выберите один API или раздел справочника FastNear, который наиболее прямо отвечает на эту задачу. Для агента важнее не вопрос «какой эндпоинт существует?», а вопрос «какой ответ поможет пользователю сделать следующий шаг?». diff --git a/static/ru/agents/index.md b/static/ru/agents/index.md index 41f6435..3c65213 100644 --- a/static/ru/agents/index.md +++ b/static/ru/agents/index.md @@ -2,8 +2,6 @@ # Агенты на FastNear -{/* FASTNEAR_AI_DISCOVERY: Это операционная точка входа для ИИ-агентов, краулеров и сред автоматизации. Страница объясняет, какую информацию собрать до первого запроса, с какого API FastNear начинать, как устроена аутентификация между API и что должен содержать полезный ответ агента. */} - Эта страница — операционная точка входа для ИИ-агентов, краулеров и сред автоматизации, использующих FastNear. Цель простая: распознать реальную задачу пользователя, выбрать один API FastNear, получить минимальный полезный результат и расширяться на другой API только тогда, когда явно не хватает части ответа. ## Если нужен только следующий шаг diff --git a/static/ru/agents/playbooks.md b/static/ru/agents/playbooks.md index a6a1821..7836158 100644 --- a/static/ru/agents/playbooks.md +++ b/static/ru/agents/playbooks.md @@ -2,8 +2,6 @@ # Плейбуки для агентов -{/* FASTNEAR_AI_DISCOVERY: Эта страница даёт ИИ-агентам конкретные многошаговые сценарии для типовых задач FastNear. Каждый плейбук называет минимальные входы, первый API, с которого начать, момент для расширения на другой API и то, что должен содержать полезный ответ. */} - Используйте эту страницу, когда агент уже знает, какой тип задачи он обрабатывает, и ему нужны ближайшие шаги по умолчанию. Каждый плейбук начинается с одного API FastNear, называет минимально полезные входы и подсказывает, когда остановиться, а когда расширяться. Базовое правило остаётся одним для всех плейбуков: начните с одного API, получите минимальный полезный результат и расширяйтесь, только когда можете точно назвать недостающую часть. diff --git a/static/ru/agents/playbooks/index.md b/static/ru/agents/playbooks/index.md index a6a1821..7836158 100644 --- a/static/ru/agents/playbooks/index.md +++ b/static/ru/agents/playbooks/index.md @@ -2,8 +2,6 @@ # Плейбуки для агентов -{/* FASTNEAR_AI_DISCOVERY: Эта страница даёт ИИ-агентам конкретные многошаговые сценарии для типовых задач FastNear. Каждый плейбук называет минимальные входы, первый API, с которого начать, момент для расширения на другой API и то, что должен содержать полезный ответ. */} - Используйте эту страницу, когда агент уже знает, какой тип задачи он обрабатывает, и ему нужны ближайшие шаги по умолчанию. Каждый плейбук начинается с одного API FastNear, называет минимально полезные входы и подсказывает, когда остановиться, а когда расширяться. Базовое правило остаётся одним для всех плейбуков: начните с одного API, получите минимальный полезный результат и расширяйтесь, только когда можете точно назвать недостающую часть. diff --git a/static/ru/llms-full.txt b/static/ru/llms-full.txt index 42962f5..89d6580 100644 --- a/static/ru/llms-full.txt +++ b/static/ru/llms-full.txt @@ -138,8 +138,6 @@ AI-читабельные Markdown-копии авторских гайдов и # Агенты на FastNear -{/* FASTNEAR_AI_DISCOVERY: Это операционная точка входа для ИИ-агентов, краулеров и сред автоматизации. Страница объясняет, какую информацию собрать до первого запроса, с какого API FastNear начинать, как устроена аутентификация между API и что должен содержать полезный ответ агента. */} - Эта страница — операционная точка входа для ИИ-агентов, краулеров и сред автоматизации, использующих FastNear. Цель простая: распознать реальную задачу пользователя, выбрать один API FastNear, получить минимальный полезный результат и расширяться на другой API только тогда, когда явно не хватает части ответа. ## Если нужен только следующий шаг @@ -393,8 +391,6 @@ const response = await fetch('https://rpc.mainnet.fastnear.com', { # Как выбрать подходящую поверхность -{/* FASTNEAR_AI_DISCOVERY: Эта страница — для ИИ-агентов, которые выбирают поверхность FastNear по намерению пользователя. Она объясняет, как перейти от цели пользователя к лучшей первой поверхности, когда комбинировать поверхности и каких типичных ошибок избегать. */} - Не начинайте с того, чтобы отдавать агенту каждый эндпоинт FastNear. Сначала сформулируйте, какую задачу на самом деле хочет решить пользователь, а затем выберите один API или раздел справочника FastNear, который наиболее прямо отвечает на эту задачу. Для агента важнее не вопрос «какой эндпоинт существует?», а вопрос «какой ответ поможет пользователю сделать следующий шаг?». @@ -658,8 +654,6 @@ const response = await fetch('https://rpc.mainnet.fastnear.com', { # Плейбуки для агентов -{/* FASTNEAR_AI_DISCOVERY: Эта страница даёт ИИ-агентам конкретные многошаговые сценарии для типовых задач FastNear. Каждый плейбук называет минимальные входы, первый API, с которого начать, момент для расширения на другой API и то, что должен содержать полезный ответ. */} - Используйте эту страницу, когда агент уже знает, какой тип задачи он обрабатывает, и ему нужны ближайшие шаги по умолчанию. Каждый плейбук начинается с одного API FastNear, называет минимально полезные входы и подсказывает, когда остановиться, а когда расширяться. Базовое правило остаётся одним для всех плейбуков: начните с одного API, получите минимальный полезный результат и расширяйтесь, только когда можете точно назвать недостающую часть. diff --git a/static/ru/structured-data/site-graph.json b/static/ru/structured-data/site-graph.json index 13c79c9..ef6a79d 100644 --- a/static/ru/structured-data/site-graph.json +++ b/static/ru/structured-data/site-graph.json @@ -17,7 +17,7 @@ "kind": "api", "name": "FastNear API", "schemaType": "WebAPI", - "@id": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "docsPageId": "https://docs.fastnear.com/ru/api#page", "docsUrl": "https://docs.fastnear.com/ru/api", "documentationUrl": "https://docs.fastnear.com/ru/api", @@ -34,7 +34,7 @@ "kind": "api", "name": "KV FastData API", "schemaType": "WebAPI", - "@id": "https://docs.fastnear.com/structured-data/families/api-kv-fastdata", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata", "docsPageId": "https://docs.fastnear.com/ru/fastdata/kv#page", "docsUrl": "https://docs.fastnear.com/ru/fastdata/kv", "documentationUrl": "https://docs.fastnear.com/ru/fastdata/kv", @@ -51,7 +51,7 @@ "kind": "api", "name": "NEAR Data API", "schemaType": "WebAPI", - "@id": "https://docs.fastnear.com/structured-data/families/api-neardata", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata", "docsPageId": "https://docs.fastnear.com/ru/neardata#page", "docsUrl": "https://docs.fastnear.com/ru/neardata", "documentationUrl": "https://docs.fastnear.com/ru/neardata", @@ -68,7 +68,7 @@ "kind": "api", "name": "Транзакции API", "schemaType": "WebAPI", - "@id": "https://docs.fastnear.com/structured-data/families/api-transactions", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions", "docsPageId": "https://docs.fastnear.com/ru/tx#page", "docsUrl": "https://docs.fastnear.com/ru/tx", "documentationUrl": "https://docs.fastnear.com/ru/tx", @@ -85,7 +85,7 @@ "kind": "api", "name": "API переводов", "schemaType": "WebAPI", - "@id": "https://docs.fastnear.com/structured-data/families/api-transfers", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transfers", "docsPageId": "https://docs.fastnear.com/ru/transfers#page", "docsUrl": "https://docs.fastnear.com/ru/transfers", "documentationUrl": "https://docs.fastnear.com/ru/transfers", @@ -102,7 +102,7 @@ "kind": "rpc", "name": "RPC аккаунта", "schemaType": "WebAPI", - "@id": "https://docs.fastnear.com/structured-data/families/rpc-account", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-account", "docsPageId": "https://docs.fastnear.com/ru/rpc#page", "docsUrl": "https://docs.fastnear.com/ru/rpc", "documentationUrl": "https://docs.fastnear.com/ru/rpc", @@ -119,7 +119,7 @@ "kind": "rpc", "name": "RPC блоков", "schemaType": "WebAPI", - "@id": "https://docs.fastnear.com/structured-data/families/rpc-block", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-block", "docsPageId": "https://docs.fastnear.com/ru/rpc#page", "docsUrl": "https://docs.fastnear.com/ru/rpc", "documentationUrl": "https://docs.fastnear.com/ru/rpc", @@ -136,7 +136,7 @@ "kind": "rpc", "name": "RPC контрактов", "schemaType": "WebAPI", - "@id": "https://docs.fastnear.com/structured-data/families/rpc-contract", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract", "docsPageId": "https://docs.fastnear.com/ru/rpc#page", "docsUrl": "https://docs.fastnear.com/ru/rpc", "documentationUrl": "https://docs.fastnear.com/ru/rpc", @@ -153,7 +153,7 @@ "kind": "rpc", "name": "RPC протокола", "schemaType": "WebAPI", - "@id": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "docsPageId": "https://docs.fastnear.com/ru/rpc#page", "docsUrl": "https://docs.fastnear.com/ru/rpc", "documentationUrl": "https://docs.fastnear.com/ru/rpc", @@ -170,7 +170,7 @@ "kind": "rpc", "name": "RPC транзакций", "schemaType": "WebAPI", - "@id": "https://docs.fastnear.com/structured-data/families/rpc-transaction", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction", "docsPageId": "https://docs.fastnear.com/ru/rpc#page", "docsUrl": "https://docs.fastnear.com/ru/rpc", "documentationUrl": "https://docs.fastnear.com/ru/rpc", @@ -187,7 +187,7 @@ "kind": "rpc", "name": "RPC валидаторов", "schemaType": "WebAPI", - "@id": "https://docs.fastnear.com/structured-data/families/rpc-validators", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-validators", "docsPageId": "https://docs.fastnear.com/ru/rpc#page", "docsUrl": "https://docs.fastnear.com/ru/rpc", "documentationUrl": "https://docs.fastnear.com/ru/rpc", @@ -222,13 +222,13 @@ "sourceSpec": "apis/fastnear/system/health.yaml", "summary": "Проверить состояние сервиса", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-system-health", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-system-health", "abstract": "Проверить состояние сервиса", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/system/health#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/system/health", "docsPageId": "https://docs.fastnear.com/ru/api/system/health#page", "docsUrl": "https://docs.fastnear.com/ru/api/system/health", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/system/health#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -267,13 +267,13 @@ "sourceSpec": "apis/fastnear/system/status.yaml", "summary": "Получить статус синхронизации сервиса", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-system-status", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-system-status", "abstract": "Получить статус синхронизации сервиса", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/system/status#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/system/status", "docsPageId": "https://docs.fastnear.com/ru/api/system/status#page", "docsUrl": "https://docs.fastnear.com/ru/api/system/status", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/system/status#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -312,13 +312,13 @@ "sourceSpec": "apis/fastnear/v0/account_ft.yaml", "summary": "Получить ID FT-контрактов аккаунта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-account-ft", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-account-ft", "abstract": "Получить ID FT-контрактов аккаунта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/v0/account_ft#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/v0/account_ft", "docsPageId": "https://docs.fastnear.com/ru/api/v0/account-ft#page", "docsUrl": "https://docs.fastnear.com/ru/api/v0/account-ft", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/v0/account-ft#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -357,13 +357,13 @@ "sourceSpec": "apis/fastnear/v0/account_nft.yaml", "summary": "Получить ID NFT-контрактов аккаунта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-account-nft", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-account-nft", "abstract": "Получить ID NFT-контрактов аккаунта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/v0/account_nft#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/v0/account_nft", "docsPageId": "https://docs.fastnear.com/ru/api/v0/account-nft#page", "docsUrl": "https://docs.fastnear.com/ru/api/v0/account-nft", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/v0/account-nft#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -402,13 +402,13 @@ "sourceSpec": "apis/fastnear/v0/account_staking.yaml", "summary": "Получить ID стейкинг-пулов аккаунта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-account-staking", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-account-staking", "abstract": "Получить ID стейкинг-пулов аккаунта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/v0/account_staking#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/v0/account_staking", "docsPageId": "https://docs.fastnear.com/ru/api/v0/account-staking#page", "docsUrl": "https://docs.fastnear.com/ru/api/v0/account-staking", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/v0/account-staking#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -447,13 +447,13 @@ "sourceSpec": "apis/fastnear/v0/public_key_lookup.yaml", "summary": "Найти аккаунты полного доступа по публичному ключу", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-public-key-lookup", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-public-key-lookup", "abstract": "Найти аккаунты полного доступа по публичному ключу", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/v0/public_key_lookup#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/v0/public_key_lookup", "docsPageId": "https://docs.fastnear.com/ru/api/v0/public-key#page", "docsUrl": "https://docs.fastnear.com/ru/api/v0/public-key", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/v0/public-key#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -492,13 +492,13 @@ "sourceSpec": "apis/fastnear/v0/public_key_lookup_all.yaml", "summary": "Найти все аккаунты по публичному ключу", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-public-key-lookup-all", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-public-key-lookup-all", "abstract": "Найти все аккаунты по публичному ключу", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/v0/public_key_lookup_all#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/v0/public_key_lookup_all", "docsPageId": "https://docs.fastnear.com/ru/api/v0/public-key-all#page", "docsUrl": "https://docs.fastnear.com/ru/api/v0/public-key-all", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/v0/public-key-all#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -537,13 +537,13 @@ "sourceSpec": "apis/fastnear/v1/account_ft.yaml", "summary": "Получить индексированные строки FT-токенов аккаунта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-account-ft", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-account-ft", "abstract": "Получить индексированные строки FT-токенов аккаунта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/account_ft#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/v1/account_ft", "docsPageId": "https://docs.fastnear.com/ru/api/v1/account-ft#page", "docsUrl": "https://docs.fastnear.com/ru/api/v1/account-ft", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/v1/account-ft#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -582,13 +582,13 @@ "sourceSpec": "apis/fastnear/v1/account_full.yaml", "summary": "Получить полный индексированный снимок аккаунта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-account-full", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-account-full", "abstract": "Получить полный индексированный снимок аккаунта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/account_full#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/v1/account_full", "docsPageId": "https://docs.fastnear.com/ru/api/v1/account-full#page", "docsUrl": "https://docs.fastnear.com/ru/api/v1/account-full", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/v1/account-full#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -627,13 +627,13 @@ "sourceSpec": "apis/fastnear/v1/account_nft.yaml", "summary": "Получить индексированные строки NFT аккаунта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-account-nft", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-account-nft", "abstract": "Получить индексированные строки NFT аккаунта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/account_nft#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/v1/account_nft", "docsPageId": "https://docs.fastnear.com/ru/api/v1/account-nft#page", "docsUrl": "https://docs.fastnear.com/ru/api/v1/account-nft", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/v1/account-nft#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -672,13 +672,13 @@ "sourceSpec": "apis/fastnear/v1/account_staking.yaml", "summary": "Поиск индексированных стейкинг-пулов аккаунта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-account-staking", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-account-staking", "abstract": "Поиск индексированных стейкинг-пулов аккаунта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/account_staking#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/v1/account_staking", "docsPageId": "https://docs.fastnear.com/ru/api/v1/account-staking#page", "docsUrl": "https://docs.fastnear.com/ru/api/v1/account-staking", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/v1/account-staking#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -717,13 +717,13 @@ "sourceSpec": "apis/fastnear/v1/ft_top.yaml", "summary": "Поиск индексированных топ-держателей FT-токена", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-ft-top", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-ft-top", "abstract": "Поиск индексированных топ-держателей FT-токена", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/ft_top#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/v1/ft_top", "docsPageId": "https://docs.fastnear.com/ru/api/v1/ft-top#page", "docsUrl": "https://docs.fastnear.com/ru/api/v1/ft-top", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/v1/ft-top#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -762,13 +762,13 @@ "sourceSpec": "apis/fastnear/v1/public_key_lookup.yaml", "summary": "Найти аккаунты полного доступа по публичному ключу", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-public-key-lookup", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-public-key-lookup", "abstract": "Найти аккаунты полного доступа по публичному ключу", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/public_key_lookup#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/v1/public_key_lookup", "docsPageId": "https://docs.fastnear.com/ru/api/v1/public-key#page", "docsUrl": "https://docs.fastnear.com/ru/api/v1/public-key", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/v1/public-key#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -807,13 +807,13 @@ "sourceSpec": "apis/fastnear/v1/public_key_lookup_all.yaml", "summary": "Найти все индексированные аккаунты по публичному ключу", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-public-key-lookup-all", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-public-key-lookup-all", "abstract": "Найти все индексированные аккаунты по публичному ключу", "canonicalPageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/public_key_lookup_all#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/fastnear/v1/public_key_lookup_all", "docsPageId": "https://docs.fastnear.com/ru/api/v1/public-key-all#page", "docsUrl": "https://docs.fastnear.com/ru/api/v1/public-key-all", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-fastnear", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/api/v1/public-key-all#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -852,13 +852,13 @@ "sourceSpec": "apis/kv-fastdata/v0/all_by_predecessor.yaml", "summary": "Получить последние строки «ключ-значение» для одного вызывающего аккаунта по всем контрактам", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-all-by-predecessor", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-all-by-predecessor", "abstract": "Получить последние строки «ключ-значение» для одного вызывающего аккаунта по всем контрактам", "canonicalPageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/all_by_predecessor#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/all_by_predecessor", "docsPageId": "https://docs.fastnear.com/ru/fastdata/kv/all-by-predecessor#page", "docsUrl": "https://docs.fastnear.com/ru/fastdata/kv/all-by-predecessor", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-kv-fastdata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/fastdata/kv/all-by-predecessor#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -897,13 +897,13 @@ "sourceSpec": "apis/kv-fastdata/v0/get_history_key.yaml", "summary": "Получить исторические строки для одного точного ключа в рамках одного вызывающего аккаунта и контракта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-get-history-key", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-get-history-key", "abstract": "Получить исторические строки для одного точного ключа в рамках одного вызывающего аккаунта и контракта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/get_history_key#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/get_history_key", "docsPageId": "https://docs.fastnear.com/ru/fastdata/kv/get-history-key#page", "docsUrl": "https://docs.fastnear.com/ru/fastdata/kv/get-history-key", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-kv-fastdata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/fastdata/kv/get-history-key#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -942,13 +942,13 @@ "sourceSpec": "apis/kv-fastdata/v0/get_latest_key.yaml", "summary": "Получить последнюю строку для одного точного ключа в рамках одного вызывающего аккаунта и контракта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-get-latest-key", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-get-latest-key", "abstract": "Получить последнюю строку для одного точного ключа в рамках одного вызывающего аккаунта и контракта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/get_latest_key#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/get_latest_key", "docsPageId": "https://docs.fastnear.com/ru/fastdata/kv/get-latest-key#page", "docsUrl": "https://docs.fastnear.com/ru/fastdata/kv/get-latest-key", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-kv-fastdata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/fastdata/kv/get-latest-key#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -987,13 +987,13 @@ "sourceSpec": "apis/kv-fastdata/v0/history_by_account.yaml", "summary": "Получить историю записей «ключ-значение» для одного контракта по всем вызывающим аккаунтам", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-history-by-account", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-history-by-account", "abstract": "Получить историю записей «ключ-значение» для одного контракта по всем вызывающим аккаунтам", "canonicalPageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/history_by_account#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/history_by_account", "docsPageId": "https://docs.fastnear.com/ru/fastdata/kv/history-by-account#page", "docsUrl": "https://docs.fastnear.com/ru/fastdata/kv/history-by-account", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-kv-fastdata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/fastdata/kv/history-by-account#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1032,13 +1032,13 @@ "sourceSpec": "apis/kv-fastdata/v0/history_by_key.yaml", "summary": "Получить историю по точному ключу во всех индексированных контрактах", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-history-by-key", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-history-by-key", "abstract": "Получить историю по точному ключу во всех индексированных контрактах", "canonicalPageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/history_by_key#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/history_by_key", "docsPageId": "https://docs.fastnear.com/ru/fastdata/kv/history-by-key#page", "docsUrl": "https://docs.fastnear.com/ru/fastdata/kv/history-by-key", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-kv-fastdata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/fastdata/kv/history-by-key#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1077,13 +1077,13 @@ "sourceSpec": "apis/kv-fastdata/v0/history_by_predecessor.yaml", "summary": "Получить историю записей «ключ-значение» для одного вызывающего аккаунта и контракта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-history-by-predecessor", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-history-by-predecessor", "abstract": "Получить историю записей «ключ-значение» для одного вызывающего аккаунта и контракта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/history_by_predecessor#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/history_by_predecessor", "docsPageId": "https://docs.fastnear.com/ru/fastdata/kv/history-by-predecessor#page", "docsUrl": "https://docs.fastnear.com/ru/fastdata/kv/history-by-predecessor", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-kv-fastdata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/fastdata/kv/history-by-predecessor#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1122,13 +1122,13 @@ "sourceSpec": "apis/kv-fastdata/v0/latest_by_account.yaml", "summary": "Получить последние строки «ключ-значение» для одного контракта по всем вызывающим аккаунтам", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-latest-by-account", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-latest-by-account", "abstract": "Получить последние строки «ключ-значение» для одного контракта по всем вызывающим аккаунтам", "canonicalPageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/latest_by_account#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/latest_by_account", "docsPageId": "https://docs.fastnear.com/ru/fastdata/kv/latest-by-account#page", "docsUrl": "https://docs.fastnear.com/ru/fastdata/kv/latest-by-account", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-kv-fastdata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/fastdata/kv/latest-by-account#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1167,13 +1167,13 @@ "sourceSpec": "apis/kv-fastdata/v0/latest_by_predecessor.yaml", "summary": "Получить последние строки «ключ-значение» для одного вызывающего аккаунта и контракта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-latest-by-predecessor", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-latest-by-predecessor", "abstract": "Получить последние строки «ключ-значение» для одного вызывающего аккаунта и контракта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/latest_by_predecessor#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/latest_by_predecessor", "docsPageId": "https://docs.fastnear.com/ru/fastdata/kv/latest-by-predecessor#page", "docsUrl": "https://docs.fastnear.com/ru/fastdata/kv/latest-by-predecessor", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-kv-fastdata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/fastdata/kv/latest-by-predecessor#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1212,13 +1212,13 @@ "sourceSpec": "apis/kv-fastdata/v0/multi.yaml", "summary": "Получить последние строки для нескольких полностью квалифицированных ключей", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-multi", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-multi", "abstract": "Получить последние строки для нескольких полностью квалифицированных ключей", "canonicalPageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/multi#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/multi", "docsPageId": "https://docs.fastnear.com/ru/fastdata/kv/multi#page", "docsUrl": "https://docs.fastnear.com/ru/fastdata/kv/multi", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-kv-fastdata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/fastdata/kv/multi#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1257,13 +1257,13 @@ "sourceSpec": "apis/neardata/system/health.yaml", "summary": "Проверить состояние сервиса", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/neardata-system-health", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-system-health", "abstract": "Проверить состояние сервиса", "canonicalPageId": "https://docs.fastnear.com/ru/apis/neardata/system/health#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/neardata/system/health", "docsPageId": "https://docs.fastnear.com/ru/neardata/system/health#page", "docsUrl": "https://docs.fastnear.com/ru/neardata/system/health", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-neardata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/neardata/system/health#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1302,13 +1302,13 @@ "sourceSpec": "apis/neardata/v0/block.yaml", "summary": "Получить финализированный блок по высоте", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block", "abstract": "Получить финализированный блок по высоте", "canonicalPageId": "https://docs.fastnear.com/ru/apis/neardata/v0/block#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/neardata/v0/block", "docsPageId": "https://docs.fastnear.com/ru/neardata/block#page", "docsUrl": "https://docs.fastnear.com/ru/neardata/block", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-neardata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/neardata/block#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1347,13 +1347,13 @@ "sourceSpec": "apis/neardata/v0/block_chunk.yaml", "summary": "Получить чанк из финализированного блока", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block-chunk", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block-chunk", "abstract": "Получить чанк из финализированного блока", "canonicalPageId": "https://docs.fastnear.com/ru/apis/neardata/v0/block_chunk#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/neardata/v0/block_chunk", "docsPageId": "https://docs.fastnear.com/ru/neardata/block-chunk#page", "docsUrl": "https://docs.fastnear.com/ru/neardata/block-chunk", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-neardata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/neardata/block-chunk#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1392,13 +1392,13 @@ "sourceSpec": "apis/neardata/v0/block_headers.yaml", "summary": "Получить объект блока для финализированного блока", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block-headers", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block-headers", "abstract": "Получить объект блока для финализированного блока", "canonicalPageId": "https://docs.fastnear.com/ru/apis/neardata/v0/block_headers#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/neardata/v0/block_headers", "docsPageId": "https://docs.fastnear.com/ru/neardata/block-headers#page", "docsUrl": "https://docs.fastnear.com/ru/neardata/block-headers", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-neardata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/neardata/block-headers#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1437,13 +1437,13 @@ "sourceSpec": "apis/neardata/v0/block_optimistic.yaml", "summary": "Получить оптимистичный блок по высоте", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block-optimistic", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block-optimistic", "abstract": "Получить оптимистичный блок по высоте", "canonicalPageId": "https://docs.fastnear.com/ru/apis/neardata/v0/block_optimistic#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/neardata/v0/block_optimistic", "docsPageId": "https://docs.fastnear.com/ru/neardata/block-optimistic#page", "docsUrl": "https://docs.fastnear.com/ru/neardata/block-optimistic", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-neardata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/neardata/block-optimistic#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1482,13 +1482,13 @@ "sourceSpec": "apis/neardata/v0/block_shard.yaml", "summary": "Получить шард из финализированного блока", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block-shard", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block-shard", "abstract": "Получить шард из финализированного блока", "canonicalPageId": "https://docs.fastnear.com/ru/apis/neardata/v0/block_shard#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/neardata/v0/block_shard", "docsPageId": "https://docs.fastnear.com/ru/neardata/block-shard#page", "docsUrl": "https://docs.fastnear.com/ru/neardata/block-shard", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-neardata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/neardata/block-shard#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1527,13 +1527,13 @@ "sourceSpec": "apis/neardata/v0/first_block.yaml", "summary": "Перенаправление на первый блок после генезиса", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/neardata-v0-first-block", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-first-block", "abstract": "Перенаправление на первый блок после генезиса", "canonicalPageId": "https://docs.fastnear.com/ru/apis/neardata/v0/first_block#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/neardata/v0/first_block", "docsPageId": "https://docs.fastnear.com/ru/neardata/first-block#page", "docsUrl": "https://docs.fastnear.com/ru/neardata/first-block", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-neardata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/neardata/first-block#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1572,13 +1572,13 @@ "sourceSpec": "apis/neardata/v0/last_block_final.yaml", "summary": "Перенаправление на последний финализированный блок", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/neardata-v0-last-block-final", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-last-block-final", "abstract": "Перенаправление на последний финализированный блок", "canonicalPageId": "https://docs.fastnear.com/ru/apis/neardata/v0/last_block_final#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/neardata/v0/last_block_final", "docsPageId": "https://docs.fastnear.com/ru/neardata/last-block-final#page", "docsUrl": "https://docs.fastnear.com/ru/neardata/last-block-final", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-neardata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/neardata/last-block-final#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1617,13 +1617,13 @@ "sourceSpec": "apis/neardata/v0/last_block_optimistic.yaml", "summary": "Перенаправление на последний оптимистичный блок", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/neardata-v0-last-block-optimistic", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-last-block-optimistic", "abstract": "Перенаправление на последний оптимистичный блок", "canonicalPageId": "https://docs.fastnear.com/ru/apis/neardata/v0/last_block_optimistic#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/neardata/v0/last_block_optimistic", "docsPageId": "https://docs.fastnear.com/ru/neardata/last-block-optimistic#page", "docsUrl": "https://docs.fastnear.com/ru/neardata/last-block-optimistic", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-neardata", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/neardata/last-block-optimistic#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1662,13 +1662,13 @@ "sourceSpec": "apis/transactions/v0/account.yaml", "summary": "Получить историю транзакций аккаунта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/transactions-v0-account", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-account", "abstract": "Получить историю транзакций аккаунта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/transactions/v0/account#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/transactions/v0/account", "docsPageId": "https://docs.fastnear.com/ru/tx/account#page", "docsUrl": "https://docs.fastnear.com/ru/tx/account", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-transactions", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/tx/account#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1707,13 +1707,13 @@ "sourceSpec": "apis/transactions/v0/block.yaml", "summary": "Получить блок по высоте или хешу", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/transactions-v0-block", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-block", "abstract": "Получить блок по высоте или хешу", "canonicalPageId": "https://docs.fastnear.com/ru/apis/transactions/v0/block#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/transactions/v0/block", "docsPageId": "https://docs.fastnear.com/ru/tx/block#page", "docsUrl": "https://docs.fastnear.com/ru/tx/block", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-transactions", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/tx/block#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1752,13 +1752,13 @@ "sourceSpec": "apis/transactions/v0/blocks.yaml", "summary": "Получить список блоков", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/transactions-v0-blocks", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-blocks", "abstract": "Получить список блоков", "canonicalPageId": "https://docs.fastnear.com/ru/apis/transactions/v0/blocks#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/transactions/v0/blocks", "docsPageId": "https://docs.fastnear.com/ru/tx/blocks#page", "docsUrl": "https://docs.fastnear.com/ru/tx/blocks", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-transactions", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/tx/blocks#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1797,13 +1797,13 @@ "sourceSpec": "apis/transactions/v0/receipt.yaml", "summary": "Получить квитанцию по ID", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/transactions-v0-receipt", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-receipt", "abstract": "Получить квитанцию по ID", "canonicalPageId": "https://docs.fastnear.com/ru/apis/transactions/v0/receipt#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/transactions/v0/receipt", "docsPageId": "https://docs.fastnear.com/ru/tx/receipt#page", "docsUrl": "https://docs.fastnear.com/ru/tx/receipt", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-transactions", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/tx/receipt#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1842,13 +1842,13 @@ "sourceSpec": "apis/transactions/v0/transactions.yaml", "summary": "Получить транзакции по хешу", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/transactions-v0-transactions", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-transactions", "abstract": "Получить транзакции по хешу", "canonicalPageId": "https://docs.fastnear.com/ru/apis/transactions/v0/transactions#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/transactions/v0/transactions", "docsPageId": "https://docs.fastnear.com/ru/tx/transactions#page", "docsUrl": "https://docs.fastnear.com/ru/tx/transactions", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-transactions", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/tx/transactions#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1886,13 +1886,13 @@ "sourceSpec": "apis/transfers/v0/transfers.yaml", "summary": "Запросить переводы аккаунта", "transport": "http", - "@id": "https://docs.fastnear.com/structured-data/operations/transfers-v0-transfers", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transfers-v0-transfers", "abstract": "Запросить переводы аккаунта", "canonicalPageId": "https://docs.fastnear.com/ru/apis/transfers/v0/transfers#page", "canonicalUrl": "https://docs.fastnear.com/ru/apis/transfers/v0/transfers", "docsPageId": "https://docs.fastnear.com/ru/transfers/query#page", "docsUrl": "https://docs.fastnear.com/ru/transfers/query", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/api-transfers", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transfers", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/transfers/query#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1932,13 +1932,13 @@ "sourceSpec": "rpcs/account/view_access_key.yaml", "summary": "Просмотр ключа доступа аккаунта", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-view-access-key", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-access-key", "abstract": "Просмотр ключа доступа аккаунта", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/account/view_access_key#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/account/view_access_key", "docsPageId": "https://docs.fastnear.com/ru/rpc/account/view-access-key#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/account/view-access-key", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-account", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-account", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/account/view-access-key#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -1979,13 +1979,13 @@ "sourceSpec": "rpcs/account/view_access_key_list.yaml", "summary": "Просмотр списка ключей доступа аккаунта", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-view-access-key-list", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-access-key-list", "abstract": "Просмотр списка ключей доступа аккаунта", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/account/view_access_key_list#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/account/view_access_key_list", "docsPageId": "https://docs.fastnear.com/ru/rpc/account/view-access-key-list#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/account/view-access-key-list", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-account", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-account", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/account/view-access-key-list#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2026,13 +2026,13 @@ "sourceSpec": "rpcs/account/view_account.yaml", "summary": "Просмотр аккаунта", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-view-account", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-account", "abstract": "Просмотр аккаунта", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/account/view_account#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/account/view_account", "docsPageId": "https://docs.fastnear.com/ru/rpc/account/view-account#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/account/view-account", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-account", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-account", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/account/view-account#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2073,13 +2073,13 @@ "sourceSpec": "rpcs/block/block_by_height.yaml", "summary": "Получить блок по высоте", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-block-by-height", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-block-by-height", "abstract": "Получить блок по высоте", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/block/block_by_height#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/block/block_by_height", "docsPageId": "https://docs.fastnear.com/ru/rpc/block/block-by-height#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/block/block-by-height", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-block", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-block", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/block/block-by-height#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2120,13 +2120,13 @@ "sourceSpec": "rpcs/block/block_by_id.yaml", "summary": "Получить блок по хешу", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-block-by-id", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-block-by-id", "abstract": "Получить блок по хешу", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/block/block_by_id#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/block/block_by_id", "docsPageId": "https://docs.fastnear.com/ru/rpc/block/block-by-id#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/block/block-by-id", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-block", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-block", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/block/block-by-id#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2167,13 +2167,13 @@ "sourceSpec": "rpcs/block/block_effects.yaml", "summary": "Получить эффекты блока", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-block-effects", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-block-effects", "abstract": "Получить эффекты блока", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/block/block_effects#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/block/block_effects", "docsPageId": "https://docs.fastnear.com/ru/rpc/block/block-effects#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/block/block-effects", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-block", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-block", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/block/block-effects#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2214,13 +2214,13 @@ "sourceSpec": "rpcs/contract/call.yaml", "summary": "Вызвать view-метод контракта", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-call-function", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-call-function", "abstract": "Вызвать view-метод контракта", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/contract/call#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/contract/call", "docsPageId": "https://docs.fastnear.com/ru/rpc/contract/call-function#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/contract/call-function", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-contract", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/contract/call-function#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2261,13 +2261,13 @@ "sourceSpec": "rpcs/contract/view_code.yaml", "summary": "Получить код контракта", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-view-code", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-code", "abstract": "Получить код контракта", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/contract/view_code#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/contract/view_code", "docsPageId": "https://docs.fastnear.com/ru/rpc/contract/view-code#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/contract/view-code", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-contract", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/contract/view-code#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2308,13 +2308,13 @@ "sourceSpec": "rpcs/contract/view_global_contract_code.yaml", "summary": "Получить глобальный код контракта", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-view-global-contract-code", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-global-contract-code", "abstract": "Получить глобальный код контракта", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/contract/view_global_contract_code#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/contract/view_global_contract_code", "docsPageId": "https://docs.fastnear.com/ru/rpc/contract/view-global-contract-code#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/contract/view-global-contract-code", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-contract", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/contract/view-global-contract-code#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2355,13 +2355,13 @@ "sourceSpec": "rpcs/contract/view_global_contract_code_by_account_id.yaml", "summary": "Получить глобальный код контракта по аккаунту", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-view-global-contract-code-by-account-id", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-global-contract-code-by-account-id", "abstract": "Получить глобальный код контракта по аккаунту", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/contract/view_global_contract_code_by_account_id#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/contract/view_global_contract_code_by_account_id", "docsPageId": "https://docs.fastnear.com/ru/rpc/contract/view-global-contract-code-by-account-id#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/contract/view-global-contract-code-by-account-id", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-contract", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/contract/view-global-contract-code-by-account-id#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2402,13 +2402,13 @@ "sourceSpec": "rpcs/contract/view_state.yaml", "summary": "Получить состояние контракта", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-view-state", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-state", "abstract": "Получить состояние контракта", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/contract/view_state#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/contract/view_state", "docsPageId": "https://docs.fastnear.com/ru/rpc/contract/view-state#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/contract/view-state", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-contract", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/contract/view-state#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2449,13 +2449,13 @@ "sourceSpec": "rpcs/protocol/changes.yaml", "summary": "Получить изменения состояния", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-changes", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-changes", "abstract": "Получить изменения состояния", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/changes#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/changes", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/changes#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/changes", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/changes#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2496,13 +2496,13 @@ "sourceSpec": "rpcs/protocol/chunk_by_block_shard.yaml", "summary": "Получить чанк по блоку и шарду", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-chunk-by-block-shard", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-chunk-by-block-shard", "abstract": "Получить чанк по блоку и шарду", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/chunk_by_block_shard#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/chunk_by_block_shard", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/chunk-by-block-shard#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/chunk-by-block-shard", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/chunk-by-block-shard#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2543,13 +2543,13 @@ "sourceSpec": "rpcs/protocol/chunk_by_hash.yaml", "summary": "Получить чанк по хешу", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-chunk-by-hash", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-chunk-by-hash", "abstract": "Получить чанк по хешу", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/chunk_by_hash#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/chunk_by_hash", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/chunk-by-hash#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/chunk-by-hash", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/chunk-by-hash#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2590,13 +2590,13 @@ "sourceSpec": "rpcs/protocol/client_config.yaml", "summary": "Получить конфигурацию клиента", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-client-config", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-client-config", "abstract": "Получить конфигурацию клиента", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/client_config#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/client_config", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/client-config#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/client-config", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/client-config#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2637,13 +2637,13 @@ "sourceSpec": "rpcs/protocol/EXPERIMENTAL_congestion_level.yaml", "summary": "Получить уровень перегрузки", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-congestion-level", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-congestion-level", "abstract": "Получить уровень перегрузки", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_congestion_level#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_congestion_level", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-congestion-level#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/experimental-congestion-level", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-congestion-level#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2684,13 +2684,13 @@ "sourceSpec": "rpcs/protocol/EXPERIMENTAL_light_client_block_proof.yaml", "summary": "Получить доказательство блока для лайт-клиента", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-light-client-block-proof", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-light-client-block-proof", "abstract": "Получить доказательство блока для лайт-клиента", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_light_client_block_proof#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_light_client_block_proof", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-light-client-block-proof#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/experimental-light-client-block-proof", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-light-client-block-proof#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2731,13 +2731,13 @@ "sourceSpec": "rpcs/protocol/EXPERIMENTAL_light_client_proof.yaml", "summary": "Получить доказательство исполнения для лайт-клиента", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-light-client-proof", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-light-client-proof", "abstract": "Получить доказательство исполнения для лайт-клиента", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_light_client_proof#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_light_client_proof", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-light-client-proof#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/experimental-light-client-proof", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-light-client-proof#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2778,13 +2778,13 @@ "sourceSpec": "rpcs/protocol/EXPERIMENTAL_protocol_config.yaml", "summary": "Получить конфигурацию протокола", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-protocol-config", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-protocol-config", "abstract": "Получить конфигурацию протокола", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_protocol_config#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_protocol_config", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-protocol-config#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/experimental-protocol-config", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-protocol-config#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2825,13 +2825,13 @@ "sourceSpec": "rpcs/protocol/EXPERIMENTAL_split_storage_info.yaml", "summary": "Получить сведения о разделённом хранилище", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-split-storage-info", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-split-storage-info", "abstract": "Получить сведения о разделённом хранилище", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_split_storage_info#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_split_storage_info", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-split-storage-info#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/experimental-split-storage-info", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-split-storage-info#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2872,13 +2872,13 @@ "sourceSpec": "rpcs/protocol/gas_price.yaml", "summary": "Получить текущую цену газа", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-gas-price", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-gas-price", "abstract": "Получить текущую цену газа", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/gas_price#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/gas_price", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/gas-price#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/gas-price", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/gas-price#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2919,13 +2919,13 @@ "sourceSpec": "rpcs/protocol/gas_price_by_block.yaml", "summary": "Получить цену газа по блоку", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-gas-price-by-block", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-gas-price-by-block", "abstract": "Получить цену газа по блоку", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/gas_price_by_block#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/gas_price_by_block", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/gas-price-by-block#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/gas-price-by-block", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/gas-price-by-block#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -2966,13 +2966,13 @@ "sourceSpec": "rpcs/protocol/genesis_config.yaml", "summary": "Получить конфигурацию генезиса", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-genesis-config", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-genesis-config", "abstract": "Получить конфигурацию генезиса", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/genesis_config#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/genesis_config", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/genesis-config#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/genesis-config", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/genesis-config#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3013,13 +3013,13 @@ "sourceSpec": "rpcs/protocol/health.yaml", "summary": "Проверить состояние узла", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-health", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-health", "abstract": "Проверить состояние узла", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/health#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/health", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/health#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/health", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/health#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3062,13 +3062,13 @@ "sourceSpec": "rpcs/protocol/latest_block.yaml", "summary": "Получить последний блок", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-latest-block", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-latest-block", "abstract": "Получить последний блок", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/latest_block#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/latest_block", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/latest-block#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/latest-block", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/latest-block#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3109,13 +3109,13 @@ "sourceSpec": "rpcs/protocol/light_client_proof.yaml", "summary": "Получить доказательство для лайт-клиента", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-light-client-proof", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-light-client-proof", "abstract": "Получить доказательство для лайт-клиента", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/light_client_proof#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/light_client_proof", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/light-client-proof#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/light-client-proof", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/light-client-proof#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3156,13 +3156,13 @@ "sourceSpec": "rpcs/protocol/maintenance_windows.yaml", "summary": "Получить окна обслуживания", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-maintenance-windows", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-maintenance-windows", "abstract": "Получить окна обслуживания", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/maintenance_windows#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/maintenance_windows", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/maintenance-windows#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/maintenance-windows", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/maintenance-windows#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3203,13 +3203,13 @@ "sourceSpec": "rpcs/protocol/metrics.yaml", "summary": "Получить метрики узла", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-metrics", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-metrics", "abstract": "Получить метрики узла", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/metrics#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/metrics", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/metrics#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/metrics", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/metrics#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3250,13 +3250,13 @@ "sourceSpec": "rpcs/protocol/network_info.yaml", "summary": "Получить сведения о сети", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-network-info", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-network-info", "abstract": "Получить сведения о сети", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/network_info#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/network_info", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/network-info#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/network-info", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/network-info#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3297,13 +3297,13 @@ "sourceSpec": "rpcs/protocol/next_light_client_block.yaml", "summary": "Получить следующий блок для лайт-клиента", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-next-light-client-block", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-next-light-client-block", "abstract": "Получить следующий блок для лайт-клиента", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/next_light_client_block#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/next_light_client_block", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/next-light-client-block#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/next-light-client-block", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/next-light-client-block#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3344,13 +3344,13 @@ "sourceSpec": "rpcs/protocol/status.yaml", "summary": "Получить статус узла", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-status", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-status", "abstract": "Получить статус узла", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/protocol/status#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/protocol/status", "docsPageId": "https://docs.fastnear.com/ru/rpc/protocol/status#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/protocol/status", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-protocol", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/protocol/status#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3391,13 +3391,13 @@ "sourceSpec": "rpcs/transaction/broadcast_tx_async.yaml", "summary": "Отправить транзакцию асинхронно", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-broadcast-tx-async", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-broadcast-tx-async", "abstract": "Отправить транзакцию асинхронно", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/transaction/broadcast_tx_async#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/transaction/broadcast_tx_async", "docsPageId": "https://docs.fastnear.com/ru/rpc/transaction/broadcast-tx-async#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/transaction/broadcast-tx-async", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-transaction", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/transaction/broadcast-tx-async#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3438,13 +3438,13 @@ "sourceSpec": "rpcs/transaction/broadcast_tx_commit.yaml", "summary": "Отправить транзакцию и дождаться подтверждения", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-broadcast-tx-commit", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-broadcast-tx-commit", "abstract": "Отправить транзакцию и дождаться подтверждения", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/transaction/broadcast_tx_commit#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/transaction/broadcast_tx_commit", "docsPageId": "https://docs.fastnear.com/ru/rpc/transaction/broadcast-tx-commit#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/transaction/broadcast-tx-commit", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-transaction", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/transaction/broadcast-tx-commit#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3485,13 +3485,13 @@ "sourceSpec": "rpcs/transaction/EXPERIMENTAL_receipt.yaml", "summary": "Получить квитанцию по ID", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-receipt", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-receipt", "abstract": "Получить квитанцию по ID", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/transaction/EXPERIMENTAL_receipt#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/transaction/EXPERIMENTAL_receipt", "docsPageId": "https://docs.fastnear.com/ru/rpc/transaction/experimental-receipt#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/transaction/experimental-receipt", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-transaction", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/transaction/experimental-receipt#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3532,13 +3532,13 @@ "sourceSpec": "rpcs/transaction/EXPERIMENTAL_tx_status.yaml", "summary": "Получить подробный статус транзакции", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-tx-status", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-tx-status", "abstract": "Получить подробный статус транзакции", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/transaction/EXPERIMENTAL_tx_status#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/transaction/EXPERIMENTAL_tx_status", "docsPageId": "https://docs.fastnear.com/ru/rpc/transaction/experimental-tx-status#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/transaction/experimental-tx-status", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-transaction", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/transaction/experimental-tx-status#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3579,13 +3579,13 @@ "sourceSpec": "rpcs/transaction/send_tx.yaml", "summary": "Отправить транзакцию", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-send-tx", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-send-tx", "abstract": "Отправить транзакцию", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/transaction/send_tx#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/transaction/send_tx", "docsPageId": "https://docs.fastnear.com/ru/rpc/transaction/send-tx#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/transaction/send-tx", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-transaction", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/transaction/send-tx#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3626,13 +3626,13 @@ "sourceSpec": "rpcs/transaction/tx_status.yaml", "summary": "Проверить статус транзакции", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-tx-status", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-tx-status", "abstract": "Проверить статус транзакции", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/transaction/tx_status#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/transaction/tx_status", "docsPageId": "https://docs.fastnear.com/ru/rpc/transaction/tx-status#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/transaction/tx-status", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-transaction", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/transaction/tx-status#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3673,13 +3673,13 @@ "sourceSpec": "rpcs/validators/EXPERIMENTAL_validators_ordered.yaml", "summary": "Получить упорядоченных валидаторов", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-validators-ordered", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-validators-ordered", "abstract": "Получить упорядоченных валидаторов", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/validators/EXPERIMENTAL_validators_ordered#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/validators/EXPERIMENTAL_validators_ordered", "docsPageId": "https://docs.fastnear.com/ru/rpc/validators/experimental-validators-ordered#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/validators/experimental-validators-ordered", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-validators", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-validators", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/validators/experimental-validators-ordered#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3720,13 +3720,13 @@ "sourceSpec": "rpcs/validators/validators_by_epoch.yaml", "summary": "Получить валидаторов по эпохе", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-validators-by-epoch", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-validators-by-epoch", "abstract": "Получить валидаторов по эпохе", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/validators/validators_by_epoch#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/validators/validators_by_epoch", "docsPageId": "https://docs.fastnear.com/ru/rpc/validators/validators-by-epoch#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/validators/validators-by-epoch", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-validators", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-validators", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/validators/validators-by-epoch#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3767,13 +3767,13 @@ "sourceSpec": "rpcs/validators/validators_current.yaml", "summary": "Получить текущих валидаторов", "transport": "json-rpc", - "@id": "https://docs.fastnear.com/structured-data/operations/rpc-validators-current", + "@id": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-validators-current", "abstract": "Получить текущих валидаторов", "canonicalPageId": "https://docs.fastnear.com/ru/rpcs/validators/validators_current#page", "canonicalUrl": "https://docs.fastnear.com/ru/rpcs/validators/validators_current", "docsPageId": "https://docs.fastnear.com/ru/rpc/validators/validators-current#page", "docsUrl": "https://docs.fastnear.com/ru/rpc/validators/validators-current", - "familyEntityId": "https://docs.fastnear.com/structured-data/families/rpc-validators", + "familyEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-validators", "inLanguage": "ru", "mainEntityOfPageId": "https://docs.fastnear.com/ru/rpc/validators/validators-current#page", "publisherId": "https://docs.fastnear.com/#organization", @@ -3870,7 +3870,7 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], "mainEntityId": null, "pageId": "https://docs.fastnear.com/ru/api#page" @@ -3911,9 +3911,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-system-health", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-system-health", "pageId": "https://docs.fastnear.com/ru/api/system/health#page" }, "indexable": true, @@ -3926,9 +3926,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-system-status", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-system-status", "pageId": "https://docs.fastnear.com/ru/api/system/status#page" }, "indexable": true, @@ -3941,9 +3941,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-account-ft", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-account-ft", "pageId": "https://docs.fastnear.com/ru/api/v0/account-ft#page" }, "indexable": true, @@ -3956,9 +3956,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-account-nft", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-account-nft", "pageId": "https://docs.fastnear.com/ru/api/v0/account-nft#page" }, "indexable": true, @@ -3971,9 +3971,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-account-staking", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-account-staking", "pageId": "https://docs.fastnear.com/ru/api/v0/account-staking#page" }, "indexable": true, @@ -3986,9 +3986,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-public-key-lookup", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-public-key-lookup", "pageId": "https://docs.fastnear.com/ru/api/v0/public-key#page" }, "indexable": true, @@ -4001,9 +4001,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-public-key-lookup-all", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-public-key-lookup-all", "pageId": "https://docs.fastnear.com/ru/api/v0/public-key-all#page" }, "indexable": true, @@ -4016,9 +4016,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-account-ft", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-account-ft", "pageId": "https://docs.fastnear.com/ru/api/v1/account-ft#page" }, "indexable": true, @@ -4031,9 +4031,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-account-full", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-account-full", "pageId": "https://docs.fastnear.com/ru/api/v1/account-full#page" }, "indexable": true, @@ -4046,9 +4046,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-account-nft", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-account-nft", "pageId": "https://docs.fastnear.com/ru/api/v1/account-nft#page" }, "indexable": true, @@ -4061,9 +4061,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-account-staking", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-account-staking", "pageId": "https://docs.fastnear.com/ru/api/v1/account-staking#page" }, "indexable": true, @@ -4076,9 +4076,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-ft-top", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-ft-top", "pageId": "https://docs.fastnear.com/ru/api/v1/ft-top#page" }, "indexable": true, @@ -4091,9 +4091,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-public-key-lookup", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-public-key-lookup", "pageId": "https://docs.fastnear.com/ru/api/v1/public-key#page" }, "indexable": true, @@ -4106,9 +4106,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-public-key-lookup-all", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-public-key-lookup-all", "pageId": "https://docs.fastnear.com/ru/api/v1/public-key-all#page" }, "indexable": true, @@ -4121,9 +4121,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-system-health", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-system-health", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/system/health#page" }, "indexable": false, @@ -4136,9 +4136,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-system-status", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-system-status", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/system/status#page" }, "indexable": false, @@ -4151,9 +4151,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-account-ft", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-account-ft", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/v0/account_ft#page" }, "indexable": false, @@ -4166,9 +4166,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-account-nft", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-account-nft", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/v0/account_nft#page" }, "indexable": false, @@ -4181,9 +4181,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-account-staking", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-account-staking", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/v0/account_staking#page" }, "indexable": false, @@ -4196,9 +4196,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-public-key-lookup", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-public-key-lookup", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/v0/public_key_lookup#page" }, "indexable": false, @@ -4211,9 +4211,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v0-public-key-lookup-all", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v0-public-key-lookup-all", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/v0/public_key_lookup_all#page" }, "indexable": false, @@ -4226,9 +4226,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-account-ft", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-account-ft", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/account_ft#page" }, "indexable": false, @@ -4241,9 +4241,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-account-full", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-account-full", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/account_full#page" }, "indexable": false, @@ -4256,9 +4256,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-account-nft", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-account-nft", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/account_nft#page" }, "indexable": false, @@ -4271,9 +4271,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-account-staking", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-account-staking", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/account_staking#page" }, "indexable": false, @@ -4286,9 +4286,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-ft-top", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-ft-top", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/ft_top#page" }, "indexable": false, @@ -4301,9 +4301,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-public-key-lookup", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-public-key-lookup", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/public_key_lookup#page" }, "indexable": false, @@ -4316,9 +4316,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-fastnear" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-fastnear" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/fastnear-v1-public-key-lookup-all", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-fastnear-v1-public-key-lookup-all", "pageId": "https://docs.fastnear.com/ru/apis/fastnear/v1/public_key_lookup_all#page" }, "indexable": false, @@ -4331,9 +4331,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-all-by-predecessor", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-all-by-predecessor", "pageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/all_by_predecessor#page" }, "indexable": false, @@ -4346,9 +4346,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-get-history-key", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-get-history-key", "pageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/get_history_key#page" }, "indexable": false, @@ -4361,9 +4361,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-get-latest-key", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-get-latest-key", "pageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/get_latest_key#page" }, "indexable": false, @@ -4376,9 +4376,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-history-by-account", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-history-by-account", "pageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/history_by_account#page" }, "indexable": false, @@ -4391,9 +4391,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-history-by-key", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-history-by-key", "pageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/history_by_key#page" }, "indexable": false, @@ -4406,9 +4406,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-history-by-predecessor", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-history-by-predecessor", "pageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/history_by_predecessor#page" }, "indexable": false, @@ -4421,9 +4421,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-latest-by-account", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-latest-by-account", "pageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/latest_by_account#page" }, "indexable": false, @@ -4436,9 +4436,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-latest-by-predecessor", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-latest-by-predecessor", "pageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/latest_by_predecessor#page" }, "indexable": false, @@ -4451,9 +4451,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-multi", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-multi", "pageId": "https://docs.fastnear.com/ru/apis/kv-fastdata/v0/multi#page" }, "indexable": false, @@ -4466,9 +4466,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-system-health", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-system-health", "pageId": "https://docs.fastnear.com/ru/apis/neardata/system/health#page" }, "indexable": false, @@ -4481,9 +4481,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block", "pageId": "https://docs.fastnear.com/ru/apis/neardata/v0/block#page" }, "indexable": false, @@ -4496,9 +4496,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block-chunk", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block-chunk", "pageId": "https://docs.fastnear.com/ru/apis/neardata/v0/block_chunk#page" }, "indexable": false, @@ -4511,9 +4511,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block-headers", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block-headers", "pageId": "https://docs.fastnear.com/ru/apis/neardata/v0/block_headers#page" }, "indexable": false, @@ -4526,9 +4526,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block-optimistic", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block-optimistic", "pageId": "https://docs.fastnear.com/ru/apis/neardata/v0/block_optimistic#page" }, "indexable": false, @@ -4541,9 +4541,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block-shard", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block-shard", "pageId": "https://docs.fastnear.com/ru/apis/neardata/v0/block_shard#page" }, "indexable": false, @@ -4556,9 +4556,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-first-block", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-first-block", "pageId": "https://docs.fastnear.com/ru/apis/neardata/v0/first_block#page" }, "indexable": false, @@ -4571,9 +4571,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-last-block-final", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-last-block-final", "pageId": "https://docs.fastnear.com/ru/apis/neardata/v0/last_block_final#page" }, "indexable": false, @@ -4586,9 +4586,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-last-block-optimistic", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-last-block-optimistic", "pageId": "https://docs.fastnear.com/ru/apis/neardata/v0/last_block_optimistic#page" }, "indexable": false, @@ -4601,9 +4601,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transactions" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/transactions-v0-account", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-account", "pageId": "https://docs.fastnear.com/ru/apis/transactions/v0/account#page" }, "indexable": false, @@ -4616,9 +4616,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transactions" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/transactions-v0-block", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-block", "pageId": "https://docs.fastnear.com/ru/apis/transactions/v0/block#page" }, "indexable": false, @@ -4631,9 +4631,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transactions" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/transactions-v0-blocks", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-blocks", "pageId": "https://docs.fastnear.com/ru/apis/transactions/v0/blocks#page" }, "indexable": false, @@ -4646,9 +4646,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transactions" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/transactions-v0-receipt", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-receipt", "pageId": "https://docs.fastnear.com/ru/apis/transactions/v0/receipt#page" }, "indexable": false, @@ -4661,9 +4661,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transactions" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/transactions-v0-transactions", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-transactions", "pageId": "https://docs.fastnear.com/ru/apis/transactions/v0/transactions#page" }, "indexable": false, @@ -4676,9 +4676,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transfers" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transfers" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/transfers-v0-transfers", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transfers-v0-transfers", "pageId": "https://docs.fastnear.com/ru/apis/transfers/v0/transfers#page" }, "indexable": false, @@ -4704,7 +4704,7 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], "mainEntityId": null, "pageId": "https://docs.fastnear.com/ru/fastdata/kv#page" @@ -4719,9 +4719,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-all-by-predecessor", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-all-by-predecessor", "pageId": "https://docs.fastnear.com/ru/fastdata/kv/all-by-predecessor#page" }, "indexable": true, @@ -4747,9 +4747,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-get-history-key", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-get-history-key", "pageId": "https://docs.fastnear.com/ru/fastdata/kv/get-history-key#page" }, "indexable": true, @@ -4762,9 +4762,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-get-latest-key", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-get-latest-key", "pageId": "https://docs.fastnear.com/ru/fastdata/kv/get-latest-key#page" }, "indexable": true, @@ -4777,9 +4777,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-history-by-account", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-history-by-account", "pageId": "https://docs.fastnear.com/ru/fastdata/kv/history-by-account#page" }, "indexable": true, @@ -4792,9 +4792,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-history-by-key", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-history-by-key", "pageId": "https://docs.fastnear.com/ru/fastdata/kv/history-by-key#page" }, "indexable": true, @@ -4807,9 +4807,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-history-by-predecessor", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-history-by-predecessor", "pageId": "https://docs.fastnear.com/ru/fastdata/kv/history-by-predecessor#page" }, "indexable": true, @@ -4822,9 +4822,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-latest-by-account", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-latest-by-account", "pageId": "https://docs.fastnear.com/ru/fastdata/kv/latest-by-account#page" }, "indexable": true, @@ -4837,9 +4837,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-latest-by-predecessor", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-latest-by-predecessor", "pageId": "https://docs.fastnear.com/ru/fastdata/kv/latest-by-predecessor#page" }, "indexable": true, @@ -4852,9 +4852,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-kv-fastdata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-kv-fastdata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/kv-fastdata-v0-multi", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-kv-fastdata-v0-multi", "pageId": "https://docs.fastnear.com/ru/fastdata/kv/multi#page" }, "indexable": true, @@ -4880,7 +4880,7 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], "mainEntityId": null, "pageId": "https://docs.fastnear.com/ru/neardata#page" @@ -4895,9 +4895,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block", "pageId": "https://docs.fastnear.com/ru/neardata/block#page" }, "indexable": true, @@ -4910,9 +4910,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block-chunk", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block-chunk", "pageId": "https://docs.fastnear.com/ru/neardata/block-chunk#page" }, "indexable": true, @@ -4925,9 +4925,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block-headers", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block-headers", "pageId": "https://docs.fastnear.com/ru/neardata/block-headers#page" }, "indexable": true, @@ -4940,9 +4940,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block-optimistic", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block-optimistic", "pageId": "https://docs.fastnear.com/ru/neardata/block-optimistic#page" }, "indexable": true, @@ -4955,9 +4955,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-block-shard", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-block-shard", "pageId": "https://docs.fastnear.com/ru/neardata/block-shard#page" }, "indexable": true, @@ -4983,9 +4983,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-first-block", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-first-block", "pageId": "https://docs.fastnear.com/ru/neardata/first-block#page" }, "indexable": true, @@ -4998,9 +4998,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-last-block-final", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-last-block-final", "pageId": "https://docs.fastnear.com/ru/neardata/last-block-final#page" }, "indexable": true, @@ -5013,9 +5013,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-v0-last-block-optimistic", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-v0-last-block-optimistic", "pageId": "https://docs.fastnear.com/ru/neardata/last-block-optimistic#page" }, "indexable": true, @@ -5028,9 +5028,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-neardata" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-neardata" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/neardata-system-health", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-neardata-system-health", "pageId": "https://docs.fastnear.com/ru/neardata/system/health#page" }, "indexable": true, @@ -5056,12 +5056,12 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-account", - "https://docs.fastnear.com/structured-data/families/rpc-block", - "https://docs.fastnear.com/structured-data/families/rpc-contract", - "https://docs.fastnear.com/structured-data/families/rpc-protocol", - "https://docs.fastnear.com/structured-data/families/rpc-transaction", - "https://docs.fastnear.com/structured-data/families/rpc-validators" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-account", + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-block", + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract", + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol", + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction", + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-validators" ], "mainEntityId": null, "pageId": "https://docs.fastnear.com/ru/rpc#page" @@ -5076,9 +5076,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-account" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-account" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-access-key", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-access-key", "pageId": "https://docs.fastnear.com/ru/rpc/account/view-access-key#page" }, "indexable": true, @@ -5091,9 +5091,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-account" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-account" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-access-key-list", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-access-key-list", "pageId": "https://docs.fastnear.com/ru/rpc/account/view-access-key-list#page" }, "indexable": true, @@ -5106,9 +5106,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-account" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-account" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-account", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-account", "pageId": "https://docs.fastnear.com/ru/rpc/account/view-account#page" }, "indexable": true, @@ -5121,9 +5121,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-block" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-block" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-block-by-height", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-block-by-height", "pageId": "https://docs.fastnear.com/ru/rpc/block/block-by-height#page" }, "indexable": true, @@ -5136,9 +5136,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-block" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-block" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-block-by-id", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-block-by-id", "pageId": "https://docs.fastnear.com/ru/rpc/block/block-by-id#page" }, "indexable": true, @@ -5151,9 +5151,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-block" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-block" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-block-effects", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-block-effects", "pageId": "https://docs.fastnear.com/ru/rpc/block/block-effects#page" }, "indexable": true, @@ -5166,9 +5166,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-contract" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-call-function", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-call-function", "pageId": "https://docs.fastnear.com/ru/rpc/contract/call-function#page" }, "indexable": true, @@ -5181,9 +5181,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-contract" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-code", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-code", "pageId": "https://docs.fastnear.com/ru/rpc/contract/view-code#page" }, "indexable": true, @@ -5196,9 +5196,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-contract" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-global-contract-code", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-global-contract-code", "pageId": "https://docs.fastnear.com/ru/rpc/contract/view-global-contract-code#page" }, "indexable": true, @@ -5211,9 +5211,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-contract" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-global-contract-code-by-account-id", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-global-contract-code-by-account-id", "pageId": "https://docs.fastnear.com/ru/rpc/contract/view-global-contract-code-by-account-id#page" }, "indexable": true, @@ -5226,9 +5226,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-contract" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-state", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-state", "pageId": "https://docs.fastnear.com/ru/rpc/contract/view-state#page" }, "indexable": true, @@ -5254,9 +5254,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-changes", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-changes", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/changes#page" }, "indexable": true, @@ -5269,9 +5269,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-chunk-by-block-shard", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-chunk-by-block-shard", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/chunk-by-block-shard#page" }, "indexable": true, @@ -5284,9 +5284,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-chunk-by-hash", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-chunk-by-hash", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/chunk-by-hash#page" }, "indexable": true, @@ -5299,9 +5299,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-client-config", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-client-config", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/client-config#page" }, "indexable": true, @@ -5314,9 +5314,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-congestion-level", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-congestion-level", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-congestion-level#page" }, "indexable": true, @@ -5329,9 +5329,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-light-client-block-proof", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-light-client-block-proof", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-light-client-block-proof#page" }, "indexable": true, @@ -5344,9 +5344,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-light-client-proof", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-light-client-proof", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-light-client-proof#page" }, "indexable": true, @@ -5359,9 +5359,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-protocol-config", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-protocol-config", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-protocol-config#page" }, "indexable": true, @@ -5374,9 +5374,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-split-storage-info", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-split-storage-info", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/experimental-split-storage-info#page" }, "indexable": true, @@ -5389,9 +5389,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-gas-price", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-gas-price", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/gas-price#page" }, "indexable": true, @@ -5404,9 +5404,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-gas-price-by-block", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-gas-price-by-block", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/gas-price-by-block#page" }, "indexable": true, @@ -5419,9 +5419,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-genesis-config", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-genesis-config", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/genesis-config#page" }, "indexable": true, @@ -5434,9 +5434,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-health", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-health", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/health#page" }, "indexable": true, @@ -5449,9 +5449,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-latest-block", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-latest-block", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/latest-block#page" }, "indexable": true, @@ -5464,9 +5464,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-light-client-proof", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-light-client-proof", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/light-client-proof#page" }, "indexable": true, @@ -5479,9 +5479,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-maintenance-windows", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-maintenance-windows", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/maintenance-windows#page" }, "indexable": true, @@ -5494,9 +5494,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-metrics", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-metrics", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/metrics#page" }, "indexable": true, @@ -5509,9 +5509,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-network-info", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-network-info", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/network-info#page" }, "indexable": true, @@ -5524,9 +5524,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-next-light-client-block", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-next-light-client-block", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/next-light-client-block#page" }, "indexable": true, @@ -5539,9 +5539,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-status", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-status", "pageId": "https://docs.fastnear.com/ru/rpc/protocol/status#page" }, "indexable": true, @@ -5554,9 +5554,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-transaction" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-broadcast-tx-async", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-broadcast-tx-async", "pageId": "https://docs.fastnear.com/ru/rpc/transaction/broadcast-tx-async#page" }, "indexable": true, @@ -5569,9 +5569,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-transaction" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-broadcast-tx-commit", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-broadcast-tx-commit", "pageId": "https://docs.fastnear.com/ru/rpc/transaction/broadcast-tx-commit#page" }, "indexable": true, @@ -5584,9 +5584,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-transaction" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-receipt", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-receipt", "pageId": "https://docs.fastnear.com/ru/rpc/transaction/experimental-receipt#page" }, "indexable": true, @@ -5599,9 +5599,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-transaction" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-tx-status", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-tx-status", "pageId": "https://docs.fastnear.com/ru/rpc/transaction/experimental-tx-status#page" }, "indexable": true, @@ -5614,9 +5614,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-transaction" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-send-tx", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-send-tx", "pageId": "https://docs.fastnear.com/ru/rpc/transaction/send-tx#page" }, "indexable": true, @@ -5629,9 +5629,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-transaction" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-tx-status", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-tx-status", "pageId": "https://docs.fastnear.com/ru/rpc/transaction/tx-status#page" }, "indexable": true, @@ -5644,9 +5644,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-validators" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-validators" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-validators-ordered", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-validators-ordered", "pageId": "https://docs.fastnear.com/ru/rpc/validators/experimental-validators-ordered#page" }, "indexable": true, @@ -5659,9 +5659,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-validators" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-validators" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-validators-by-epoch", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-validators-by-epoch", "pageId": "https://docs.fastnear.com/ru/rpc/validators/validators-by-epoch#page" }, "indexable": true, @@ -5674,9 +5674,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-validators" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-validators" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-validators-current", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-validators-current", "pageId": "https://docs.fastnear.com/ru/rpc/validators/validators-current#page" }, "indexable": true, @@ -5689,9 +5689,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-account" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-account" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-access-key", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-access-key", "pageId": "https://docs.fastnear.com/ru/rpcs/account/view_access_key#page" }, "indexable": false, @@ -5704,9 +5704,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-account" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-account" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-access-key-list", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-access-key-list", "pageId": "https://docs.fastnear.com/ru/rpcs/account/view_access_key_list#page" }, "indexable": false, @@ -5719,9 +5719,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-account" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-account" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-account", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-account", "pageId": "https://docs.fastnear.com/ru/rpcs/account/view_account#page" }, "indexable": false, @@ -5734,9 +5734,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-block" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-block" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-block-by-height", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-block-by-height", "pageId": "https://docs.fastnear.com/ru/rpcs/block/block_by_height#page" }, "indexable": false, @@ -5749,9 +5749,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-block" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-block" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-block-by-id", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-block-by-id", "pageId": "https://docs.fastnear.com/ru/rpcs/block/block_by_id#page" }, "indexable": false, @@ -5764,9 +5764,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-block" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-block" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-block-effects", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-block-effects", "pageId": "https://docs.fastnear.com/ru/rpcs/block/block_effects#page" }, "indexable": false, @@ -5779,9 +5779,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-contract" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-call-function", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-call-function", "pageId": "https://docs.fastnear.com/ru/rpcs/contract/call#page" }, "indexable": false, @@ -5794,9 +5794,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-contract" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-code", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-code", "pageId": "https://docs.fastnear.com/ru/rpcs/contract/view_code#page" }, "indexable": false, @@ -5809,9 +5809,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-contract" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-global-contract-code", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-global-contract-code", "pageId": "https://docs.fastnear.com/ru/rpcs/contract/view_global_contract_code#page" }, "indexable": false, @@ -5824,9 +5824,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-contract" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-global-contract-code-by-account-id", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-global-contract-code-by-account-id", "pageId": "https://docs.fastnear.com/ru/rpcs/contract/view_global_contract_code_by_account_id#page" }, "indexable": false, @@ -5839,9 +5839,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-contract" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-contract" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-view-state", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-view-state", "pageId": "https://docs.fastnear.com/ru/rpcs/contract/view_state#page" }, "indexable": false, @@ -5854,9 +5854,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-changes", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-changes", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/changes#page" }, "indexable": false, @@ -5869,9 +5869,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-chunk-by-block-shard", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-chunk-by-block-shard", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/chunk_by_block_shard#page" }, "indexable": false, @@ -5884,9 +5884,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-chunk-by-hash", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-chunk-by-hash", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/chunk_by_hash#page" }, "indexable": false, @@ -5899,9 +5899,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-client-config", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-client-config", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/client_config#page" }, "indexable": false, @@ -5914,9 +5914,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-congestion-level", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-congestion-level", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_congestion_level#page" }, "indexable": false, @@ -5929,9 +5929,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-light-client-block-proof", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-light-client-block-proof", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_light_client_block_proof#page" }, "indexable": false, @@ -5944,9 +5944,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-light-client-proof", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-light-client-proof", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_light_client_proof#page" }, "indexable": false, @@ -5959,9 +5959,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-protocol-config", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-protocol-config", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_protocol_config#page" }, "indexable": false, @@ -5974,9 +5974,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-split-storage-info", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-split-storage-info", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/EXPERIMENTAL_split_storage_info#page" }, "indexable": false, @@ -5989,9 +5989,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-gas-price", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-gas-price", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/gas_price#page" }, "indexable": false, @@ -6004,9 +6004,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-gas-price-by-block", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-gas-price-by-block", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/gas_price_by_block#page" }, "indexable": false, @@ -6019,9 +6019,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-genesis-config", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-genesis-config", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/genesis_config#page" }, "indexable": false, @@ -6034,9 +6034,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-health", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-health", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/health#page" }, "indexable": false, @@ -6049,9 +6049,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-latest-block", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-latest-block", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/latest_block#page" }, "indexable": false, @@ -6064,9 +6064,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-light-client-proof", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-light-client-proof", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/light_client_proof#page" }, "indexable": false, @@ -6079,9 +6079,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-maintenance-windows", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-maintenance-windows", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/maintenance_windows#page" }, "indexable": false, @@ -6094,9 +6094,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-metrics", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-metrics", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/metrics#page" }, "indexable": false, @@ -6109,9 +6109,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-network-info", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-network-info", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/network_info#page" }, "indexable": false, @@ -6124,9 +6124,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-next-light-client-block", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-next-light-client-block", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/next_light_client_block#page" }, "indexable": false, @@ -6139,9 +6139,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-protocol" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-protocol" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-status", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-status", "pageId": "https://docs.fastnear.com/ru/rpcs/protocol/status#page" }, "indexable": false, @@ -6154,9 +6154,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-transaction" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-broadcast-tx-async", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-broadcast-tx-async", "pageId": "https://docs.fastnear.com/ru/rpcs/transaction/broadcast_tx_async#page" }, "indexable": false, @@ -6169,9 +6169,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-transaction" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-broadcast-tx-commit", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-broadcast-tx-commit", "pageId": "https://docs.fastnear.com/ru/rpcs/transaction/broadcast_tx_commit#page" }, "indexable": false, @@ -6184,9 +6184,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-transaction" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-receipt", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-receipt", "pageId": "https://docs.fastnear.com/ru/rpcs/transaction/EXPERIMENTAL_receipt#page" }, "indexable": false, @@ -6199,9 +6199,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-transaction" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-tx-status", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-tx-status", "pageId": "https://docs.fastnear.com/ru/rpcs/transaction/EXPERIMENTAL_tx_status#page" }, "indexable": false, @@ -6214,9 +6214,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-transaction" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-send-tx", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-send-tx", "pageId": "https://docs.fastnear.com/ru/rpcs/transaction/send_tx#page" }, "indexable": false, @@ -6229,9 +6229,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-transaction" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-transaction" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-tx-status", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-tx-status", "pageId": "https://docs.fastnear.com/ru/rpcs/transaction/tx_status#page" }, "indexable": false, @@ -6244,9 +6244,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-validators" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-validators" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-EXPERIMENTAL-validators-ordered", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-EXPERIMENTAL-validators-ordered", "pageId": "https://docs.fastnear.com/ru/rpcs/validators/EXPERIMENTAL_validators_ordered#page" }, "indexable": false, @@ -6259,9 +6259,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-validators" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-validators" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-validators-by-epoch", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-validators-by-epoch", "pageId": "https://docs.fastnear.com/ru/rpcs/validators/validators_by_epoch#page" }, "indexable": false, @@ -6274,9 +6274,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/rpc-validators" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-rpc-validators" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/rpc-validators-current", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-rpc-validators-current", "pageId": "https://docs.fastnear.com/ru/rpcs/validators/validators_current#page" }, "indexable": false, @@ -6341,7 +6341,7 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transfers" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transfers" ], "mainEntityId": null, "pageId": "https://docs.fastnear.com/ru/transfers#page" @@ -6369,9 +6369,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transfers" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transfers" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/transfers-v0-transfers", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transfers-v0-transfers", "pageId": "https://docs.fastnear.com/ru/transfers/query#page" }, "indexable": true, @@ -6384,7 +6384,7 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transactions" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions" ], "mainEntityId": null, "pageId": "https://docs.fastnear.com/ru/tx#page" @@ -6399,9 +6399,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transactions" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/transactions-v0-account", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-account", "pageId": "https://docs.fastnear.com/ru/tx/account#page" }, "indexable": true, @@ -6414,9 +6414,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transactions" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/transactions-v0-block", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-block", "pageId": "https://docs.fastnear.com/ru/tx/block#page" }, "indexable": true, @@ -6429,9 +6429,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transactions" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/transactions-v0-blocks", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-blocks", "pageId": "https://docs.fastnear.com/ru/tx/blocks#page" }, "indexable": true, @@ -6470,9 +6470,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transactions" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/transactions-v0-receipt", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-receipt", "pageId": "https://docs.fastnear.com/ru/tx/receipt#page" }, "indexable": true, @@ -6498,9 +6498,9 @@ { "entityIds": { "familyIds": [ - "https://docs.fastnear.com/structured-data/families/api-transactions" + "https://docs.fastnear.com/ru/structured-data/site-graph.json#family-api-transactions" ], - "mainEntityId": "https://docs.fastnear.com/structured-data/operations/transactions-v0-transactions", + "mainEntityId": "https://docs.fastnear.com/ru/structured-data/site-graph.json#operation-transactions-v0-transactions", "pageId": "https://docs.fastnear.com/ru/tx/transactions#page" }, "indexable": true, From d1c50e4ceb4c763eddcaa3f40fec89378bdbd7b1 Mon Sep 17 00:00:00 2001 From: Mike Purvis Date: Sat, 25 Apr 2026 11:56:34 -0700 Subject: [PATCH 2/3] regen: ai surfaces and ru artifacts on top of main --- static/.well-known/agent-skills/auth/SKILL.md | 21 +- static/.well-known/agent-skills/index.json | 8 +- .../agent-skills/overview/SKILL.md | 20 +- .../agent-skills/playbooks/SKILL.md | 7 + .../agent-skills/surface-routing/SKILL.md | 7 + static/ru/api/examples.md | 38 +--- static/ru/api/examples/index.md | 38 +--- static/ru/fastdata/kv/examples.md | 23 +- static/ru/fastdata/kv/examples/index.md | 23 +- static/ru/llms-full.txt | 197 +++++------------- static/ru/neardata/examples.md | 36 +--- static/ru/neardata/examples/index.md | 36 +--- static/ru/rpc/examples.md | 41 ++-- static/ru/rpc/examples/index.md | 41 ++-- static/ru/transfers/examples.md | 20 +- static/ru/transfers/examples/index.md | 20 +- static/ru/tx/examples.md | 37 +--- static/ru/tx/examples/berry-club.md | 2 - static/ru/tx/examples/berry-club/index.md | 2 - static/ru/tx/examples/index.md | 37 +--- 20 files changed, 201 insertions(+), 453 deletions(-) diff --git a/static/.well-known/agent-skills/auth/SKILL.md b/static/.well-known/agent-skills/auth/SKILL.md index df0e69e..b88cb0c 100644 --- a/static/.well-known/agent-skills/auth/SKILL.md +++ b/static/.well-known/agent-skills/auth/SKILL.md @@ -8,7 +8,7 @@ description: "Authentication guidance for FastNear agents. Use when a task invol Agents should authenticate to FastNear the same way production backends do. Do not copy the browser-demo posture used by the docs UI into an agent, worker, or automation runtime. -One FastNear API key works across the RPC and API endpoints. Many public reads still work without a key. For agents, the important question is not whether auth exists. It is where the credential lives, how it gets attached to requests, and how to avoid leaking it into prompts, logs, or browser state. +One FastNear API key works across the RPC and API endpoints. For agents, the important question is not whether auth exists. It is where the credential lives, how it gets attached to requests, and how to avoid leaking it into prompts, logs, or browser state. ## If you only need the rule @@ -32,8 +32,8 @@ Avoid browser-only agent architectures that need the FastNear key in client-side | Transport | Use it when... | Notes | | --- | --- | --- | -| `Authorization: Bearer ${API_KEY}` | you control the HTTP client or backend | Best default for agents. Less likely to leak into URL logs, analytics, or copied links. | -| `?apiKey=${API_KEY}` | you are using simple curl or a system that cannot easily set headers | Still valid, but URLs tend to travel further through logs and tooling. Use it intentionally. | +| `Authorization: Bearer ${FASTNEAR_API_KEY}` | you control the HTTP client or backend | Best default for agents. Less likely to leak into URL logs, analytics, or copied links. | +| `?apiKey=${FASTNEAR_API_KEY}` | you are using simple curl or a system that cannot easily set headers | Still valid, but URLs tend to travel further through logs and tooling. Use it intentionally. | If you have a choice, use the header form. @@ -64,13 +64,13 @@ const response = await fetch('https://rpc.mainnet.fastnear.com', { }); ``` -## When auth is missing +## If the runtime is missing the key -Many public FastNear endpoints are still readable without a key. If the agent can answer the user's question from public traffic, do that. +Agents should normally start with a configured FastNear API key. Some public FastNear reads may still work without one, but that should not be the default operating posture. -When a key is required for higher limits, paid access, or authenticated traffic: +If the configured runtime does not have the key yet: -- tell the user to create or retrieve a key from [dashboard.fastnear.com](https://dashboard.fastnear.com) +- tell the user to create or retrieve a key from [FastNear Dashboard](https://dashboard.fastnear.com) - ask them to configure it in an env var, secret manager, or backend configuration - do not ask them to paste the raw key into chat so the agent can carry it around @@ -97,3 +97,10 @@ When auth is relevant, a useful agent answer usually contains: - [Auth & Access](https://docs.fastnear.com/auth) - [Agents on FastNear](https://docs.fastnear.com/agents) - [Choosing the Right Surface](https://docs.fastnear.com/agents/choosing-surfaces) +--- +## About FastNear + +- FastNear handles 10B+ requests per month. +- FastNear runs 100+ nodes worldwide. +- One FastNear API key works across RPC and the indexed APIs. +- Get an API key at [dashboard.fastnear.com](https://dashboard.fastnear.com). diff --git a/static/.well-known/agent-skills/index.json b/static/.well-known/agent-skills/index.json index 068d7f9..f601766 100644 --- a/static/.well-known/agent-skills/index.json +++ b/static/.well-known/agent-skills/index.json @@ -3,28 +3,28 @@ "skills": [ { "description": "Operational entry point for FastNear agents. Use when you need the default workflow, discovery surfaces, and the first API to reach for.", - "digest": "sha256:e45e8632c088e252dc5e445d50c7883a87d63eab06b872471f3f855486336ec1", + "digest": "sha256:2b288a595c408e177bc12b78bd29762335e540626075e0ff6a85a9658b64e8e3", "name": "overview", "type": "skill-md", "url": "/.well-known/agent-skills/overview/SKILL.md" }, { "description": "Surface-selection guide for FastNear. Use when you need to route a task to RPC, FastNear API, history APIs, NEAR Data, FastData, or snapshots.", - "digest": "sha256:4e74891dad49f3a1e619e7e447f84991b13439bf31621885e8d1e59d00217b12", + "digest": "sha256:d61b03f6493b86d9755a4bb30e53cbc894bed8f1cea419b7f3f8afd9b5becf2d", "name": "surface-routing", "type": "skill-md", "url": "/.well-known/agent-skills/surface-routing/SKILL.md" }, { "description": "Authentication guidance for FastNear agents. Use when a task involves API keys, secret handling, or request authorization posture.", - "digest": "sha256:70af39bbfb033f5fa65f4bc135b16a61b074de21a5b3b8a9d24c85fc496303b0", + "digest": "sha256:bbd8fba5f68df2bb53bc96774e92276f3d546df633b75961dbc45b867d799a3b", "name": "auth", "type": "skill-md", "url": "/.well-known/agent-skills/auth/SKILL.md" }, { "description": "Common FastNear playbooks for agents. Use when you need the default multi-step workflow for holdings, transaction tracing, transfers, block monitoring, storage, or snapshots.", - "digest": "sha256:dfe12a735e69b6dd3a21cfffe32c2c64cd55e47200ba156106a5b91c31735e8e", + "digest": "sha256:ed7ae7fdce45258ce1321d19f7321b0942bef53a6bc1a1b789082a7ac62113ed", "name": "playbooks", "type": "skill-md", "url": "/.well-known/agent-skills/playbooks/SKILL.md" diff --git a/static/.well-known/agent-skills/overview/SKILL.md b/static/.well-known/agent-skills/overview/SKILL.md index 3c1c8d0..21caf32 100644 --- a/static/.well-known/agent-skills/overview/SKILL.md +++ b/static/.well-known/agent-skills/overview/SKILL.md @@ -19,6 +19,7 @@ This page is the operational starting point for AI agents, crawlers, and automat - Use indexed APIs when the user wants a product-shaped answer such as balances, holdings, account history, or transfer history. - Use [RPC Reference](https://docs.fastnear.com/rpc) when the user needs canonical protocol-native fields, contract calls, or transaction submission. +- If you are using the hosted JS runtime at [js.fastnear.com](https://js.fastnear.com), start with low-level methods such as `near.view`, `near.queryAccount`, and `near.tx.*`, and use `near.recipes.*` only when a task helper is the shortest path to the answer. - Use [NEAR Data API](https://docs.fastnear.com/neardata) when the question is about recent optimistic or finalized blocks and explicit polling. - Use [Snapshots](https://docs.fastnear.com/snapshots) for operator workflows, not application-level data reads. - One FastNear API key works across the RPC and API endpoints. @@ -92,20 +93,24 @@ Bad pattern: ## Authenticate once, reuse everywhere -Public endpoints often work without a key. Add a key for higher limits, a shared authenticated posture, or paid access patterns. The same key works across every FastNear API above, including the regular and archival RPC hosts; send it either as an HTTP header or a URL parameter: +Start with a FastNear API key and reuse it across every FastNear API above, including the regular and archival RPC hosts. Send it either as an HTTP header or a URL parameter: ```bash title="Authorization header" +: "${FASTNEAR_API_KEY:?Set FASTNEAR_API_KEY in your shell before running this example.}" + curl "https://rpc.mainnet.fastnear.com" \ - -H "Authorization: Bearer ${API_KEY}" \ + -H "Authorization: Bearer $FASTNEAR_API_KEY" \ -H "Content-Type: application/json" \ --data '{"method":"block","params":{"finality":"final"},"id":1,"jsonrpc":"2.0"}' ``` ```bash title="URL parameter" -curl "https://rpc.mainnet.fastnear.com?apiKey=${API_KEY}" +: "${FASTNEAR_API_KEY:?Set FASTNEAR_API_KEY in your shell before running this example.}" + +curl "https://rpc.mainnet.fastnear.com?apiKey=$FASTNEAR_API_KEY" ``` -Get a key from [dashboard.fastnear.com](https://dashboard.fastnear.com). Operational posture for non-interactive runtimes: [Auth for Agents](https://docs.fastnear.com/agents/auth) — keys go in env vars or a secret manager, never in browser storage, chat logs, or prompts. Full flow and header details: [Auth & Access](https://docs.fastnear.com/auth). +Get your API key from [FastNear Dashboard](https://dashboard.fastnear.com). Operational posture for non-interactive runtimes: [Auth for Agents](https://docs.fastnear.com/agents/auth) — keys go in env vars or a secret manager, never in browser storage, chat logs, or prompts. Full flow and header details: [Auth & Access](https://docs.fastnear.com/auth). ## Pull clean docs into a prompt @@ -139,3 +144,10 @@ Avoid dumping raw payloads when the user is really asking for interpretation. - Need routing depth and tradeoffs? [Choosing the Right Surface](https://docs.fastnear.com/agents/choosing-surfaces) - Need credential posture and secret handling? [Auth for Agents](https://docs.fastnear.com/agents/auth) - Need example workflows? [Agent Playbooks](https://docs.fastnear.com/agents/playbooks) +--- +## About FastNear + +- FastNear handles 10B+ requests per month. +- FastNear runs 100+ nodes worldwide. +- One FastNear API key works across RPC and the indexed APIs. +- Get an API key at [dashboard.fastnear.com](https://dashboard.fastnear.com). diff --git a/static/.well-known/agent-skills/playbooks/SKILL.md b/static/.well-known/agent-skills/playbooks/SKILL.md index 50a6b4c..3487f1b 100644 --- a/static/.well-known/agent-skills/playbooks/SKILL.md +++ b/static/.well-known/agent-skills/playbooks/SKILL.md @@ -262,3 +262,10 @@ If the request is still ambiguous after reading this page: - use [Choosing the Right Surface](https://docs.fastnear.com/agents/choosing-surfaces) to pick the first API - use [Auth for Agents](https://docs.fastnear.com/agents/auth) if the blocker is credential handling - return to [Agents on FastNear](https://docs.fastnear.com/agents) for the default workflow and answer-shape rules +--- +## About FastNear + +- FastNear handles 10B+ requests per month. +- FastNear runs 100+ nodes worldwide. +- One FastNear API key works across RPC and the indexed APIs. +- Get an API key at [dashboard.fastnear.com](https://dashboard.fastnear.com). diff --git a/static/.well-known/agent-skills/surface-routing/SKILL.md b/static/.well-known/agent-skills/surface-routing/SKILL.md index 3a1bcec..72a2f5b 100644 --- a/static/.well-known/agent-skills/surface-routing/SKILL.md +++ b/static/.well-known/agent-skills/surface-routing/SKILL.md @@ -257,3 +257,10 @@ The goal is not to prove that multiple FastNear APIs exist. The goal is to answe - [Agents on FastNear](https://docs.fastnear.com/agents) for the full surface map, base URLs, and prompt-ingestion hints. - [Auth for Agents](https://docs.fastnear.com/agents/auth) for credential handling and runtime posture. - [Agent Playbooks](https://docs.fastnear.com/agents/playbooks) for example multi-step workflows. +--- +## About FastNear + +- FastNear handles 10B+ requests per month. +- FastNear runs 100+ nodes worldwide. +- One FastNear API key works across RPC and the indexed APIs. +- Get an API key at [dashboard.fastnear.com](https://dashboard.fastnear.com). diff --git a/static/ru/api/examples.md b/static/ru/api/examples.md index 9d35825..d45e47a 100644 --- a/static/ru/api/examples.md +++ b/static/ru/api/examples.md @@ -2,7 +2,7 @@ ## Примеры -Все shell-примеры ниже работают на публичных FastNear API-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически добавляют bearer header; если переменная не задана, они переходят на публичный неаутентифицированный путь. +Все shell-примеры ниже работают на публичных FastNear API-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически передают его как query-параметр `apiKey`; если переменная не задана, они переходят на публичный неаутентифицированный путь. Также поддерживается bearer-аутентификация через `Authorization: Bearer ${FASTNEAR_API_KEY}`, если вашему клиенту удобнее передавать ключ в заголовке. ### Свести один аккаунт за один вызов @@ -10,11 +10,8 @@ ```bash ACCOUNT_ID=root.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{ account_id, near_balance_yocto: .state.balance, @@ -32,18 +29,14 @@ curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ ```bash PUBLIC_KEY='ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT' -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -LOOKUP="$(curl -s "https://api.fastnear.com/v1/public_key/$(jq -rn --arg k "$PUBLIC_KEY" '$k | @uri')" \ - "${AUTH_HEADER[@]}")" +LOOKUP="$(curl -s "https://api.fastnear.com/v1/public_key/$(jq -rn --arg k "$PUBLIC_KEY" '$k | @uri')?apiKey=${FASTNEAR_API_KEY:-}")" echo "$LOOKUP" | jq '{matched: (.account_ids | length), account_ids}' ACCOUNT_ID="$(echo "$LOOKUP" | jq -r '.account_ids[0]')" -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{account_id, state, tokens: (.tokens|length), nfts: (.nfts|length), pools: (.pools|length)}' ``` @@ -55,11 +48,8 @@ curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ ```bash ACCOUNT_ID=root.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full?apiKey=${FASTNEAR_API_KEY:-}" \ | jq ' (.state.balance | tonumber) as $amount | (.state.locked | tonumber) as $locked @@ -89,11 +79,8 @@ jq считает в IEEE-754 double, поэтому NEAR-значения вы ```bash ACCOUNT_ID=root.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full?apiKey=${FASTNEAR_API_KEY:-}" \ | jq ' [ (.tokens // [])[].last_update_block_height, @@ -121,11 +108,8 @@ curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ ```bash ACCOUNT_ID=root.near PUBLISHER=sharddog.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/nft" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/nft?apiKey=${FASTNEAR_API_KEY:-}" \ | jq --arg publisher "$PUBLISHER" ' ("." + $publisher) as $suffix | { @@ -154,13 +138,9 @@ curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/nft" \ ```bash ACCOUNT_ID=root.near LIQUID_PROVIDERS_JSON='["meta-pool.near","lst.rhealab.near","linear-protocol.near"]' -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -STAKING="$(curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/staking" \ - "${AUTH_HEADER[@]}")" -FT="$(curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/ft" \ - "${AUTH_HEADER[@]}")" +STAKING="$(curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/staking?apiKey=${FASTNEAR_API_KEY:-}")" +FT="$(curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/ft?apiKey=${FASTNEAR_API_KEY:-}")" jq -n \ --argjson staking "$STAKING" \ diff --git a/static/ru/api/examples/index.md b/static/ru/api/examples/index.md index 9d35825..d45e47a 100644 --- a/static/ru/api/examples/index.md +++ b/static/ru/api/examples/index.md @@ -2,7 +2,7 @@ ## Примеры -Все shell-примеры ниже работают на публичных FastNear API-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически добавляют bearer header; если переменная не задана, они переходят на публичный неаутентифицированный путь. +Все shell-примеры ниже работают на публичных FastNear API-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически передают его как query-параметр `apiKey`; если переменная не задана, они переходят на публичный неаутентифицированный путь. Также поддерживается bearer-аутентификация через `Authorization: Bearer ${FASTNEAR_API_KEY}`, если вашему клиенту удобнее передавать ключ в заголовке. ### Свести один аккаунт за один вызов @@ -10,11 +10,8 @@ ```bash ACCOUNT_ID=root.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{ account_id, near_balance_yocto: .state.balance, @@ -32,18 +29,14 @@ curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ ```bash PUBLIC_KEY='ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT' -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -LOOKUP="$(curl -s "https://api.fastnear.com/v1/public_key/$(jq -rn --arg k "$PUBLIC_KEY" '$k | @uri')" \ - "${AUTH_HEADER[@]}")" +LOOKUP="$(curl -s "https://api.fastnear.com/v1/public_key/$(jq -rn --arg k "$PUBLIC_KEY" '$k | @uri')?apiKey=${FASTNEAR_API_KEY:-}")" echo "$LOOKUP" | jq '{matched: (.account_ids | length), account_ids}' ACCOUNT_ID="$(echo "$LOOKUP" | jq -r '.account_ids[0]')" -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{account_id, state, tokens: (.tokens|length), nfts: (.nfts|length), pools: (.pools|length)}' ``` @@ -55,11 +48,8 @@ curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ ```bash ACCOUNT_ID=root.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full?apiKey=${FASTNEAR_API_KEY:-}" \ | jq ' (.state.balance | tonumber) as $amount | (.state.locked | tonumber) as $locked @@ -89,11 +79,8 @@ jq считает в IEEE-754 double, поэтому NEAR-значения вы ```bash ACCOUNT_ID=root.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full?apiKey=${FASTNEAR_API_KEY:-}" \ | jq ' [ (.tokens // [])[].last_update_block_height, @@ -121,11 +108,8 @@ curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ ```bash ACCOUNT_ID=root.near PUBLISHER=sharddog.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/nft" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/nft?apiKey=${FASTNEAR_API_KEY:-}" \ | jq --arg publisher "$PUBLISHER" ' ("." + $publisher) as $suffix | { @@ -154,13 +138,9 @@ curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/nft" \ ```bash ACCOUNT_ID=root.near LIQUID_PROVIDERS_JSON='["meta-pool.near","lst.rhealab.near","linear-protocol.near"]' -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -STAKING="$(curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/staking" \ - "${AUTH_HEADER[@]}")" -FT="$(curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/ft" \ - "${AUTH_HEADER[@]}")" +STAKING="$(curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/staking?apiKey=${FASTNEAR_API_KEY:-}")" +FT="$(curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/ft?apiKey=${FASTNEAR_API_KEY:-}")" jq -n \ --argjson staking "$STAKING" \ diff --git a/static/ru/fastdata/kv/examples.md b/static/ru/fastdata/kv/examples.md index 269d82d..9279051 100644 --- a/static/ru/fastdata/kv/examples.md +++ b/static/ru/fastdata/kv/examples.md @@ -2,7 +2,7 @@ ## Примеры -Все shell-примеры ниже работают на публичных KV FastData-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически добавляют bearer header; если переменная не задана, они переходят на публичный неаутентифицированный путь. +Все shell-примеры ниже работают на публичных KV FastData-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически передают его как query-параметр `apiKey`; если переменная не задана, они переходят на публичный неаутентифицированный путь. Также поддерживается bearer-аутентификация через `Authorization: Bearer ${FASTNEAR_API_KEY}`, если вашему клиенту удобнее передавать ключ в заголовке. ### Проверить один точный ключ и сразу посмотреть его историю @@ -12,13 +12,10 @@ CURRENT_ACCOUNT_ID=social.near PREDECESSOR_ID=james.near KEY='graph/follow/sleet.near' -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi ENCODED_KEY="$(jq -rn --arg key "$KEY" '$key | @uri')" -LATEST="$(curl -s "https://kv.main.fastnear.com/v0/latest/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY" \ - "${AUTH_HEADER[@]}")" +LATEST="$(curl -s "https://kv.main.fastnear.com/v0/latest/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY?apiKey=${FASTNEAR_API_KEY:-}")" echo "$LATEST" | jq '{ latest: ( @@ -33,8 +30,7 @@ echo "$LATEST" | jq '{ ) }' -curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{writes: [.entries[] | {block_height, value}]}' ``` @@ -46,11 +42,8 @@ curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSO ```bash PREDECESSOR_ID=jemartel.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -FIRST="$(curl -s "https://kv.main.fastnear.com/v0/all/$PREDECESSOR_ID" \ - "${AUTH_HEADER[@]}" \ +FIRST="$(curl -s "https://kv.main.fastnear.com/v0/all/$PREDECESSOR_ID?apiKey=${FASTNEAR_API_KEY:-}" \ -H 'content-type: application/json' \ --data '{"include_metadata":true,"limit":10}')" @@ -66,10 +59,7 @@ echo "$FIRST" | jq '{ ```bash PREDECESSOR_ID=jemartel.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -FIRST="$(curl -s "https://kv.main.fastnear.com/v0/all/$PREDECESSOR_ID" \ - "${AUTH_HEADER[@]}" \ +FIRST="$(curl -s "https://kv.main.fastnear.com/v0/all/$PREDECESSOR_ID?apiKey=${FASTNEAR_API_KEY:-}" \ -H 'content-type: application/json' \ --data '{"include_metadata":true,"limit":10}')" @@ -77,8 +67,7 @@ CURRENT_ACCOUNT_ID="$(echo "$FIRST" | jq -r '.entries[0].current_account_id')" EXACT_KEY="$(echo "$FIRST" | jq -r '.entries[0].key')" ENCODED_KEY="$(jq -rn --arg key "$EXACT_KEY" '$key | @uri')" -curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{entries: [.entries[] | {block_height, value}]}' ``` diff --git a/static/ru/fastdata/kv/examples/index.md b/static/ru/fastdata/kv/examples/index.md index 269d82d..9279051 100644 --- a/static/ru/fastdata/kv/examples/index.md +++ b/static/ru/fastdata/kv/examples/index.md @@ -2,7 +2,7 @@ ## Примеры -Все shell-примеры ниже работают на публичных KV FastData-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически добавляют bearer header; если переменная не задана, они переходят на публичный неаутентифицированный путь. +Все shell-примеры ниже работают на публичных KV FastData-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически передают его как query-параметр `apiKey`; если переменная не задана, они переходят на публичный неаутентифицированный путь. Также поддерживается bearer-аутентификация через `Authorization: Bearer ${FASTNEAR_API_KEY}`, если вашему клиенту удобнее передавать ключ в заголовке. ### Проверить один точный ключ и сразу посмотреть его историю @@ -12,13 +12,10 @@ CURRENT_ACCOUNT_ID=social.near PREDECESSOR_ID=james.near KEY='graph/follow/sleet.near' -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi ENCODED_KEY="$(jq -rn --arg key "$KEY" '$key | @uri')" -LATEST="$(curl -s "https://kv.main.fastnear.com/v0/latest/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY" \ - "${AUTH_HEADER[@]}")" +LATEST="$(curl -s "https://kv.main.fastnear.com/v0/latest/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY?apiKey=${FASTNEAR_API_KEY:-}")" echo "$LATEST" | jq '{ latest: ( @@ -33,8 +30,7 @@ echo "$LATEST" | jq '{ ) }' -curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{writes: [.entries[] | {block_height, value}]}' ``` @@ -46,11 +42,8 @@ curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSO ```bash PREDECESSOR_ID=jemartel.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -FIRST="$(curl -s "https://kv.main.fastnear.com/v0/all/$PREDECESSOR_ID" \ - "${AUTH_HEADER[@]}" \ +FIRST="$(curl -s "https://kv.main.fastnear.com/v0/all/$PREDECESSOR_ID?apiKey=${FASTNEAR_API_KEY:-}" \ -H 'content-type: application/json' \ --data '{"include_metadata":true,"limit":10}')" @@ -66,10 +59,7 @@ echo "$FIRST" | jq '{ ```bash PREDECESSOR_ID=jemartel.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -FIRST="$(curl -s "https://kv.main.fastnear.com/v0/all/$PREDECESSOR_ID" \ - "${AUTH_HEADER[@]}" \ +FIRST="$(curl -s "https://kv.main.fastnear.com/v0/all/$PREDECESSOR_ID?apiKey=${FASTNEAR_API_KEY:-}" \ -H 'content-type: application/json' \ --data '{"include_metadata":true,"limit":10}')" @@ -77,8 +67,7 @@ CURRENT_ACCOUNT_ID="$(echo "$FIRST" | jq -r '.entries[0].current_account_id')" EXACT_KEY="$(echo "$FIRST" | jq -r '.entries[0].key')" ENCODED_KEY="$(jq -rn --arg key "$EXACT_KEY" '$key | @uri')" -curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{entries: [.entries[] | {block_height, value}]}' ``` diff --git a/static/ru/llms-full.txt b/static/ru/llms-full.txt index 89d6580..272df8d 100644 --- a/static/ru/llms-full.txt +++ b/static/ru/llms-full.txt @@ -995,7 +995,7 @@ https://test.api.fastnear.com ## Примеры -Все shell-примеры ниже работают на публичных FastNear API-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически добавляют bearer header; если переменная не задана, они переходят на публичный неаутентифицированный путь. +Все shell-примеры ниже работают на публичных FastNear API-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически передают его как query-параметр `apiKey`; если переменная не задана, они переходят на публичный неаутентифицированный путь. Также поддерживается bearer-аутентификация через `Authorization: Bearer ${FASTNEAR_API_KEY}`, если вашему клиенту удобнее передавать ключ в заголовке. ### Свести один аккаунт за один вызов @@ -1003,11 +1003,8 @@ https://test.api.fastnear.com ```bash ACCOUNT_ID=root.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{ account_id, near_balance_yocto: .state.balance, @@ -1025,18 +1022,14 @@ curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ ```bash PUBLIC_KEY='ed25519:CCaThr3uokqnUs6Z5vVnaDcJdrfuTpYJHJWcAGubDjT' -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -LOOKUP="$(curl -s "https://api.fastnear.com/v1/public_key/$(jq -rn --arg k "$PUBLIC_KEY" '$k | @uri')" \ - "${AUTH_HEADER[@]}")" +LOOKUP="$(curl -s "https://api.fastnear.com/v1/public_key/$(jq -rn --arg k "$PUBLIC_KEY" '$k | @uri')?apiKey=${FASTNEAR_API_KEY:-}")" echo "$LOOKUP" | jq '{matched: (.account_ids | length), account_ids}' ACCOUNT_ID="$(echo "$LOOKUP" | jq -r '.account_ids[0]')" -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{account_id, state, tokens: (.tokens|length), nfts: (.nfts|length), pools: (.pools|length)}' ``` @@ -1048,11 +1041,8 @@ curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ ```bash ACCOUNT_ID=root.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full?apiKey=${FASTNEAR_API_KEY:-}" \ | jq ' (.state.balance | tonumber) as $amount | (.state.locked | tonumber) as $locked @@ -1082,11 +1072,8 @@ jq считает в IEEE-754 double, поэтому NEAR-значения вы ```bash ACCOUNT_ID=root.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full?apiKey=${FASTNEAR_API_KEY:-}" \ | jq ' [ (.tokens // [])[].last_update_block_height, @@ -1114,11 +1101,8 @@ curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/full" \ ```bash ACCOUNT_ID=root.near PUBLISHER=sharddog.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/nft" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/nft?apiKey=${FASTNEAR_API_KEY:-}" \ | jq --arg publisher "$PUBLISHER" ' ("." + $publisher) as $suffix | { @@ -1147,13 +1131,9 @@ curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/nft" \ ```bash ACCOUNT_ID=root.near LIQUID_PROVIDERS_JSON='["meta-pool.near","lst.rhealab.near","linear-protocol.near"]' -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -STAKING="$(curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/staking" \ - "${AUTH_HEADER[@]}")" -FT="$(curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/ft" \ - "${AUTH_HEADER[@]}")" +STAKING="$(curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/staking?apiKey=${FASTNEAR_API_KEY:-}")" +FT="$(curl -s "https://api.fastnear.com/v1/account/$ACCOUNT_ID/ft?apiKey=${FASTNEAR_API_KEY:-}")" jq -n \ --argjson staking "$STAKING" \ @@ -1418,7 +1398,7 @@ curl -s "https://kv.main.fastnear.com/v0/latest/$CURRENT_ACCOUNT_ID/$PREDECESSOR ## Примеры -Все shell-примеры ниже работают на публичных KV FastData-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически добавляют bearer header; если переменная не задана, они переходят на публичный неаутентифицированный путь. +Все shell-примеры ниже работают на публичных KV FastData-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически передают его как query-параметр `apiKey`; если переменная не задана, они переходят на публичный неаутентифицированный путь. Также поддерживается bearer-аутентификация через `Authorization: Bearer ${FASTNEAR_API_KEY}`, если вашему клиенту удобнее передавать ключ в заголовке. ### Проверить один точный ключ и сразу посмотреть его историю @@ -1428,13 +1408,10 @@ curl -s "https://kv.main.fastnear.com/v0/latest/$CURRENT_ACCOUNT_ID/$PREDECESSOR CURRENT_ACCOUNT_ID=social.near PREDECESSOR_ID=james.near KEY='graph/follow/sleet.near' -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi ENCODED_KEY="$(jq -rn --arg key "$KEY" '$key | @uri')" -LATEST="$(curl -s "https://kv.main.fastnear.com/v0/latest/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY" \ - "${AUTH_HEADER[@]}")" +LATEST="$(curl -s "https://kv.main.fastnear.com/v0/latest/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY?apiKey=${FASTNEAR_API_KEY:-}")" echo "$LATEST" | jq '{ latest: ( @@ -1449,8 +1426,7 @@ echo "$LATEST" | jq '{ ) }' -curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{writes: [.entries[] | {block_height, value}]}' ``` @@ -1462,11 +1438,8 @@ curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSO ```bash PREDECESSOR_ID=jemartel.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -FIRST="$(curl -s "https://kv.main.fastnear.com/v0/all/$PREDECESSOR_ID" \ - "${AUTH_HEADER[@]}" \ +FIRST="$(curl -s "https://kv.main.fastnear.com/v0/all/$PREDECESSOR_ID?apiKey=${FASTNEAR_API_KEY:-}" \ -H 'content-type: application/json' \ --data '{"include_metadata":true,"limit":10}')" @@ -1482,10 +1455,7 @@ echo "$FIRST" | jq '{ ```bash PREDECESSOR_ID=jemartel.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -FIRST="$(curl -s "https://kv.main.fastnear.com/v0/all/$PREDECESSOR_ID" \ - "${AUTH_HEADER[@]}" \ +FIRST="$(curl -s "https://kv.main.fastnear.com/v0/all/$PREDECESSOR_ID?apiKey=${FASTNEAR_API_KEY:-}" \ -H 'content-type: application/json' \ --data '{"include_metadata":true,"limit":10}')" @@ -1493,8 +1463,7 @@ CURRENT_ACCOUNT_ID="$(echo "$FIRST" | jq -r '.entries[0].current_account_id')" EXACT_KEY="$(echo "$FIRST" | jq -r '.entries[0].key')" ENCODED_KEY="$(jq -rn --arg key "$EXACT_KEY" '$key | @uri')" -curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://kv.main.fastnear.com/v0/history/$CURRENT_ACCOUNT_ID/$PREDECESSOR_ID/$ENCODED_KEY?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{entries: [.entries[] | {block_height, value}]}' ``` @@ -1856,18 +1825,15 @@ https://testnet.neardata.xyz NEAR Data возвращает каждый блок полностью гидратированным одним JSON-документом — header плюс per-shard chunks, receipts, результаты исполнения и state changes, — так что один `curl` уже даёт всё необходимое, чтобы отфильтровать нужный контракт без второго запроса. -Все shell-примеры ниже работают на публичных NEAR Data-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически добавляют bearer header; если переменная не задана, они переходят на публичный неаутентифицированный путь. +Все shell-примеры ниже работают на публичных NEAR Data-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически передают его как query-параметр `apiKey`; если переменная не задана, они переходят на публичный неаутентифицированный путь. Также поддерживается bearer-аутентификация через `Authorization: Bearer ${FASTNEAR_API_KEY}`, если вашему клиенту удобнее передавать ключ в заголовке. ### На каком блоке NEAR сейчас? `/v0/last_block/final` отдаёт 302-редирект на текущий финализированный блок. Прежде чем фильтровать по конкретному контракту, полезно увидеть, как выглядит один блок на уровне протокола: транзакции приходят с разбивкой по shard, поэтому общее число транзакций в блоке — это сумма по shards, а не одно поле верхнего уровня. ```bash -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -sL "https://mainnet.neardata.xyz/v0/last_block/final" \ - "${AUTH_HEADER[@]}" \ +curl -sL "https://mainnet.neardata.xyz/v0/last_block/final?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{ height: .block.header.height, timestamp_nanosec: .block.header.timestamp_nanosec, @@ -1884,11 +1850,8 @@ curl -sL "https://mainnet.neardata.xyz/v0/last_block/final" \ ```bash TARGET_CONTRACT=intents.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -sL "https://mainnet.neardata.xyz/v0/last_block/final" \ - "${AUTH_HEADER[@]}" \ +curl -sL "https://mainnet.neardata.xyz/v0/last_block/final?apiKey=${FASTNEAR_API_KEY:-}" \ | jq --arg contract "$TARGET_CONTRACT" '{ height: .block.header.height, contract: $contract, @@ -1910,8 +1873,6 @@ Optimistic-блоки ходят по `/v0/block_opt/{height}` примерно ```bash TARGET_CONTRACT=intents.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi count_touches() { jq --arg contract "$1" ' @@ -1922,15 +1883,14 @@ count_touches() { } OPT_LOCATION="$( - curl -s -D - -o /dev/null "${AUTH_HEADER[@]}" "https://mainnet.neardata.xyz/v0/last_block/optimistic" \ + curl -s -D - -o /dev/null "https://mainnet.neardata.xyz/v0/last_block/optimistic?apiKey=${FASTNEAR_API_KEY:-}" \ | awk 'tolower($1) == "location:" {print $2}' | tr -d '\r' )" -OPT_HEIGHT="${OPT_LOCATION##*/}" +OPT_PATH="${OPT_LOCATION%%\?*}" +OPT_HEIGHT="${OPT_PATH##*/}" -echo "optimistic @ $OPT_HEIGHT: $(curl -s "https://mainnet.neardata.xyz$OPT_LOCATION" \ - "${AUTH_HEADER[@]}" | count_touches "$TARGET_CONTRACT") touches" -FINAL="$(curl -s "https://mainnet.neardata.xyz/v0/block/$OPT_HEIGHT" \ - "${AUTH_HEADER[@]}")" +echo "optimistic @ $OPT_HEIGHT: $(curl -s "https://mainnet.neardata.xyz$OPT_PATH?apiKey=${FASTNEAR_API_KEY:-}" | count_touches "$TARGET_CONTRACT") touches" +FINAL="$(curl -s "https://mainnet.neardata.xyz/v0/block/$OPT_HEIGHT?apiKey=${FASTNEAR_API_KEY:-}")" if [ "$(printf '%s' "$FINAL" | jq 'type')" = '"null"' ]; then echo "finalized @ $OPT_HEIGHT: not caught up yet" else @@ -1946,18 +1906,14 @@ fi ```bash TARGET_CONTRACT=intents.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -HEAD="$(curl -sL "https://mainnet.neardata.xyz/v0/last_block/final" \ - "${AUTH_HEADER[@]}" | jq '.block.header.height')" +HEAD="$(curl -sL "https://mainnet.neardata.xyz/v0/last_block/final?apiKey=${FASTNEAR_API_KEY:-}" | jq '.block.header.height')" FOUND_HEIGHT="" FOUND_SHARD="" for OFFSET in $(seq 0 15); do H=$((HEAD - OFFSET)) - SHARD="$(curl -s "https://mainnet.neardata.xyz/v0/block/$H" \ - "${AUTH_HEADER[@]}" \ + SHARD="$(curl -s "https://mainnet.neardata.xyz/v0/block/$H?apiKey=${FASTNEAR_API_KEY:-}" \ | jq -r --arg contract "$TARGET_CONTRACT" ' .shards[] | select([.state_changes[]? | select(.change.account_id? == $contract)] | length > 0) @@ -1972,8 +1928,7 @@ done if [ -z "$FOUND_HEIGHT" ]; then echo "no state mutation for $TARGET_CONTRACT in the last 16 finalized blocks" else - curl -s "https://mainnet.neardata.xyz/v0/block/$FOUND_HEIGHT/shard/$FOUND_SHARD" \ - "${AUTH_HEADER[@]}" \ + curl -s "https://mainnet.neardata.xyz/v0/block/$FOUND_HEIGHT/shard/$FOUND_SHARD?apiKey=${FASTNEAR_API_KEY:-}" \ | jq --arg contract "$TARGET_CONTRACT" --argjson height "$FOUND_HEIGHT" --argjson shard_id "$FOUND_SHARD" '{ height: $height, shard_id: $shard_id, @@ -2152,7 +2107,7 @@ https://archival-rpc.testnet.fastnear.com Начинайте с RPC-метода, который отвечает на вопрос. Используйте `tx`, чтобы отследить включение и финальность по хешу транзакции, и расширяйте поверхность только когда нужны дерево receipts, сырой state или трассировка на уровне shard. -Все shell-примеры ниже работают на публичных RPC-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически добавляют bearer header; если переменная не задана, они переходят на публичный неаутентифицированный путь. +Все shell-примеры ниже работают на публичных RPC-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически передают его как query-параметр `apiKey`; если переменная не задана, они переходят на публичный неаутентифицированный путь. Также поддерживается bearer-аутентификация через `Authorization: Bearer ${FASTNEAR_API_KEY}`, если вашему клиенту удобнее передавать ключ в заголовке. ## Состояние аккаунта @@ -2162,11 +2117,8 @@ https://archival-rpc.testnet.fastnear.com ```bash ACCOUNT_ID=root.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://rpc.mainnet.fastnear.com" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" \ -H 'content-type: application/json' \ --data "$(jq -nc --arg account_id "$ACCOUNT_ID" '{ jsonrpc:"2.0",id:"fastnear",method:"query", @@ -2186,11 +2138,8 @@ curl -s "https://rpc.mainnet.fastnear.com" \ ```bash TX_HASH=CVyG2xLJ6fuKCtULAxMnWTh2GL5ey2UUiTcgYT3M6Pow SIGNER_ACCOUNT_ID=mike.testnet -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://archival-rpc.testnet.fastnear.com" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://archival-rpc.testnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" \ -H 'content-type: application/json' \ --data "$(jq -nc --arg tx_hash "$TX_HASH" --arg signer_id "$SIGNER_ACCOUNT_ID" '{ jsonrpc: "2.0", id: "fastnear", method: "tx", @@ -2219,14 +2168,12 @@ curl -s "https://archival-rpc.testnet.fastnear.com" \ ```bash EMPTY_TX_ROOT=11111111111111111111111111111111 -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -BLOCK_HASH="$(curl -s "https://rpc.mainnet.fastnear.com" "${AUTH_HEADER[@]}" -H 'content-type: application/json' \ +BLOCK_HASH="$(curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" -H 'content-type: application/json' \ --data '{"jsonrpc":"2.0","id":"fastnear","method":"status","params":[]}' \ | jq -r '.result.sync_info.latest_block_hash')" -CHUNK_HASH="$(curl -s "https://rpc.mainnet.fastnear.com" "${AUTH_HEADER[@]}" -H 'content-type: application/json' \ +CHUNK_HASH="$(curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" -H 'content-type: application/json' \ --data "$(jq -nc --arg block_hash "$BLOCK_HASH" '{ jsonrpc:"2.0",id:"fastnear",method:"block",params:{block_id:$block_hash} }')" \ @@ -2236,7 +2183,7 @@ CHUNK_HASH="$(curl -s "https://rpc.mainnet.fastnear.com" "${AUTH_HEADER[@]}" -H if [ -z "$CHUNK_HASH" ]; then echo "tip block had no transactions in any chunk — rerun on the next head" else - curl -s "https://rpc.mainnet.fastnear.com" "${AUTH_HEADER[@]}" -H 'content-type: application/json' \ + curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" -H 'content-type: application/json' \ --data "$(jq -nc --arg chunk_hash "$CHUNK_HASH" '{ jsonrpc:"2.0",id:"fastnear",method:"chunk",params:{chunk_id:$chunk_hash} }')" \ @@ -2276,11 +2223,8 @@ fi ```bash ACCOUNT_ID=root.near RECEIVER_ID=social.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://rpc.mainnet.fastnear.com" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" \ -H 'content-type: application/json' \ --data "$(jq -nc --arg account_id "$ACCOUNT_ID" '{ jsonrpc:"2.0",id:"fastnear",method:"query", @@ -2318,10 +2262,8 @@ View-метод вроде `get_num` всё равно заставляет уз ```bash CONTRACT_ID=counter.near-examples.testnet -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -RAW_B64="$(curl -s "https://rpc.testnet.fastnear.com" "${AUTH_HEADER[@]}" -H 'content-type: application/json' \ +RAW_B64="$(curl -s "https://rpc.testnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" -H 'content-type: application/json' \ --data "$(jq -nc --arg contract "$CONTRACT_ID" '{ jsonrpc:"2.0",id:"fastnear",method:"query", params:{request_type:"view_state",account_id:$contract,prefix_base64:"U1RBVEU=",finality:"final"} @@ -2348,12 +2290,10 @@ jq -n --arg raw "$RAW_B64" --argjson val "$DECODED_I8" '{raw_bytes_base64: $raw, ```bash ACCOUNT_ID=root.near # account you're writing under SIGNER_ACCOUNT_ID=root.near # account signing the transaction -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi STORAGE_ARGS_B64="$(jq -nc --arg account_id "$ACCOUNT_ID" '{account_id:$account_id}' | base64 | tr -d '\n')" -STORAGE="$(curl -s "https://rpc.mainnet.fastnear.com" "${AUTH_HEADER[@]}" -H 'content-type: application/json' \ +STORAGE="$(curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" -H 'content-type: application/json' \ --data "$(jq -nc --arg args "$STORAGE_ARGS_B64" '{ jsonrpc:"2.0",id:"fastnear",method:"query", params:{request_type:"call_function",account_id:"social.near",method_name:"get_account_storage",args_base64:$args,finality:"final"} @@ -2364,7 +2304,7 @@ if [ "$SIGNER_ACCOUNT_ID" = "$ACCOUNT_ID" ]; then PERMISSION=true else PERM_ARGS_B64="$(jq -nc --arg pred "$SIGNER_ACCOUNT_ID" --arg key "$ACCOUNT_ID" '{predecessor_id:$pred,key:$key}' | base64 | tr -d '\n')" - PERMISSION="$(curl -s "https://rpc.mainnet.fastnear.com" "${AUTH_HEADER[@]}" -H 'content-type: application/json' \ + PERMISSION="$(curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" -H 'content-type: application/json' \ --data "$(jq -nc --arg args "$PERM_ARGS_B64" '{ jsonrpc:"2.0",id:"fastnear",method:"query", params:{request_type:"call_function",account_id:"social.near",method_name:"is_write_permission_granted",args_base64:$args,finality:"final"} @@ -2391,15 +2331,13 @@ SocialDB хранит BOS-виджеты как ключи `/widget/ 0) @@ -120,8 +107,7 @@ done if [ -z "$FOUND_HEIGHT" ]; then echo "no state mutation for $TARGET_CONTRACT in the last 16 finalized blocks" else - curl -s "https://mainnet.neardata.xyz/v0/block/$FOUND_HEIGHT/shard/$FOUND_SHARD" \ - "${AUTH_HEADER[@]}" \ + curl -s "https://mainnet.neardata.xyz/v0/block/$FOUND_HEIGHT/shard/$FOUND_SHARD?apiKey=${FASTNEAR_API_KEY:-}" \ | jq --arg contract "$TARGET_CONTRACT" --argjson height "$FOUND_HEIGHT" --argjson shard_id "$FOUND_SHARD" '{ height: $height, shard_id: $shard_id, diff --git a/static/ru/neardata/examples/index.md b/static/ru/neardata/examples/index.md index 3639e91..1d1ff1a 100644 --- a/static/ru/neardata/examples/index.md +++ b/static/ru/neardata/examples/index.md @@ -4,18 +4,15 @@ NEAR Data возвращает каждый блок полностью гидратированным одним JSON-документом — header плюс per-shard chunks, receipts, результаты исполнения и state changes, — так что один `curl` уже даёт всё необходимое, чтобы отфильтровать нужный контракт без второго запроса. -Все shell-примеры ниже работают на публичных NEAR Data-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически добавляют bearer header; если переменная не задана, они переходят на публичный неаутентифицированный путь. +Все shell-примеры ниже работают на публичных NEAR Data-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически передают его как query-параметр `apiKey`; если переменная не задана, они переходят на публичный неаутентифицированный путь. Также поддерживается bearer-аутентификация через `Authorization: Bearer ${FASTNEAR_API_KEY}`, если вашему клиенту удобнее передавать ключ в заголовке. ### На каком блоке NEAR сейчас? `/v0/last_block/final` отдаёт 302-редирект на текущий финализированный блок. Прежде чем фильтровать по конкретному контракту, полезно увидеть, как выглядит один блок на уровне протокола: транзакции приходят с разбивкой по shard, поэтому общее число транзакций в блоке — это сумма по shards, а не одно поле верхнего уровня. ```bash -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -sL "https://mainnet.neardata.xyz/v0/last_block/final" \ - "${AUTH_HEADER[@]}" \ +curl -sL "https://mainnet.neardata.xyz/v0/last_block/final?apiKey=${FASTNEAR_API_KEY:-}" \ | jq '{ height: .block.header.height, timestamp_nanosec: .block.header.timestamp_nanosec, @@ -32,11 +29,8 @@ curl -sL "https://mainnet.neardata.xyz/v0/last_block/final" \ ```bash TARGET_CONTRACT=intents.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -sL "https://mainnet.neardata.xyz/v0/last_block/final" \ - "${AUTH_HEADER[@]}" \ +curl -sL "https://mainnet.neardata.xyz/v0/last_block/final?apiKey=${FASTNEAR_API_KEY:-}" \ | jq --arg contract "$TARGET_CONTRACT" '{ height: .block.header.height, contract: $contract, @@ -58,8 +52,6 @@ Optimistic-блоки ходят по `/v0/block_opt/{height}` примерно ```bash TARGET_CONTRACT=intents.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi count_touches() { jq --arg contract "$1" ' @@ -70,15 +62,14 @@ count_touches() { } OPT_LOCATION="$( - curl -s -D - -o /dev/null "${AUTH_HEADER[@]}" "https://mainnet.neardata.xyz/v0/last_block/optimistic" \ + curl -s -D - -o /dev/null "https://mainnet.neardata.xyz/v0/last_block/optimistic?apiKey=${FASTNEAR_API_KEY:-}" \ | awk 'tolower($1) == "location:" {print $2}' | tr -d '\r' )" -OPT_HEIGHT="${OPT_LOCATION##*/}" +OPT_PATH="${OPT_LOCATION%%\?*}" +OPT_HEIGHT="${OPT_PATH##*/}" -echo "optimistic @ $OPT_HEIGHT: $(curl -s "https://mainnet.neardata.xyz$OPT_LOCATION" \ - "${AUTH_HEADER[@]}" | count_touches "$TARGET_CONTRACT") touches" -FINAL="$(curl -s "https://mainnet.neardata.xyz/v0/block/$OPT_HEIGHT" \ - "${AUTH_HEADER[@]}")" +echo "optimistic @ $OPT_HEIGHT: $(curl -s "https://mainnet.neardata.xyz$OPT_PATH?apiKey=${FASTNEAR_API_KEY:-}" | count_touches "$TARGET_CONTRACT") touches" +FINAL="$(curl -s "https://mainnet.neardata.xyz/v0/block/$OPT_HEIGHT?apiKey=${FASTNEAR_API_KEY:-}")" if [ "$(printf '%s' "$FINAL" | jq 'type')" = '"null"' ]; then echo "finalized @ $OPT_HEIGHT: not caught up yet" else @@ -94,18 +85,14 @@ fi ```bash TARGET_CONTRACT=intents.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -HEAD="$(curl -sL "https://mainnet.neardata.xyz/v0/last_block/final" \ - "${AUTH_HEADER[@]}" | jq '.block.header.height')" +HEAD="$(curl -sL "https://mainnet.neardata.xyz/v0/last_block/final?apiKey=${FASTNEAR_API_KEY:-}" | jq '.block.header.height')" FOUND_HEIGHT="" FOUND_SHARD="" for OFFSET in $(seq 0 15); do H=$((HEAD - OFFSET)) - SHARD="$(curl -s "https://mainnet.neardata.xyz/v0/block/$H" \ - "${AUTH_HEADER[@]}" \ + SHARD="$(curl -s "https://mainnet.neardata.xyz/v0/block/$H?apiKey=${FASTNEAR_API_KEY:-}" \ | jq -r --arg contract "$TARGET_CONTRACT" ' .shards[] | select([.state_changes[]? | select(.change.account_id? == $contract)] | length > 0) @@ -120,8 +107,7 @@ done if [ -z "$FOUND_HEIGHT" ]; then echo "no state mutation for $TARGET_CONTRACT in the last 16 finalized blocks" else - curl -s "https://mainnet.neardata.xyz/v0/block/$FOUND_HEIGHT/shard/$FOUND_SHARD" \ - "${AUTH_HEADER[@]}" \ + curl -s "https://mainnet.neardata.xyz/v0/block/$FOUND_HEIGHT/shard/$FOUND_SHARD?apiKey=${FASTNEAR_API_KEY:-}" \ | jq --arg contract "$TARGET_CONTRACT" --argjson height "$FOUND_HEIGHT" --argjson shard_id "$FOUND_SHARD" '{ height: $height, shard_id: $shard_id, diff --git a/static/ru/rpc/examples.md b/static/ru/rpc/examples.md index 7d6cbcd..8daf432 100644 --- a/static/ru/rpc/examples.md +++ b/static/ru/rpc/examples.md @@ -4,7 +4,7 @@ Начинайте с RPC-метода, который отвечает на вопрос. Используйте `tx`, чтобы отследить включение и финальность по хешу транзакции, и расширяйте поверхность только когда нужны дерево receipts, сырой state или трассировка на уровне shard. -Все shell-примеры ниже работают на публичных RPC-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически добавляют bearer header; если переменная не задана, они переходят на публичный неаутентифицированный путь. +Все shell-примеры ниже работают на публичных RPC-хостах как есть. Если в shell задан `FASTNEAR_API_KEY`, они автоматически передают его как query-параметр `apiKey`; если переменная не задана, они переходят на публичный неаутентифицированный путь. Также поддерживается bearer-аутентификация через `Authorization: Bearer ${FASTNEAR_API_KEY}`, если вашему клиенту удобнее передавать ключ в заголовке. ## Состояние аккаунта @@ -14,11 +14,8 @@ ```bash ACCOUNT_ID=root.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://rpc.mainnet.fastnear.com" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" \ -H 'content-type: application/json' \ --data "$(jq -nc --arg account_id "$ACCOUNT_ID" '{ jsonrpc:"2.0",id:"fastnear",method:"query", @@ -38,11 +35,8 @@ curl -s "https://rpc.mainnet.fastnear.com" \ ```bash TX_HASH=CVyG2xLJ6fuKCtULAxMnWTh2GL5ey2UUiTcgYT3M6Pow SIGNER_ACCOUNT_ID=mike.testnet -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://archival-rpc.testnet.fastnear.com" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://archival-rpc.testnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" \ -H 'content-type: application/json' \ --data "$(jq -nc --arg tx_hash "$TX_HASH" --arg signer_id "$SIGNER_ACCOUNT_ID" '{ jsonrpc: "2.0", id: "fastnear", method: "tx", @@ -71,14 +65,12 @@ curl -s "https://archival-rpc.testnet.fastnear.com" \ ```bash EMPTY_TX_ROOT=11111111111111111111111111111111 -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -BLOCK_HASH="$(curl -s "https://rpc.mainnet.fastnear.com" "${AUTH_HEADER[@]}" -H 'content-type: application/json' \ +BLOCK_HASH="$(curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" -H 'content-type: application/json' \ --data '{"jsonrpc":"2.0","id":"fastnear","method":"status","params":[]}' \ | jq -r '.result.sync_info.latest_block_hash')" -CHUNK_HASH="$(curl -s "https://rpc.mainnet.fastnear.com" "${AUTH_HEADER[@]}" -H 'content-type: application/json' \ +CHUNK_HASH="$(curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" -H 'content-type: application/json' \ --data "$(jq -nc --arg block_hash "$BLOCK_HASH" '{ jsonrpc:"2.0",id:"fastnear",method:"block",params:{block_id:$block_hash} }')" \ @@ -88,7 +80,7 @@ CHUNK_HASH="$(curl -s "https://rpc.mainnet.fastnear.com" "${AUTH_HEADER[@]}" -H if [ -z "$CHUNK_HASH" ]; then echo "tip block had no transactions in any chunk — rerun on the next head" else - curl -s "https://rpc.mainnet.fastnear.com" "${AUTH_HEADER[@]}" -H 'content-type: application/json' \ + curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" -H 'content-type: application/json' \ --data "$(jq -nc --arg chunk_hash "$CHUNK_HASH" '{ jsonrpc:"2.0",id:"fastnear",method:"chunk",params:{chunk_id:$chunk_hash} }')" \ @@ -128,11 +120,8 @@ fi ```bash ACCOUNT_ID=root.near RECEIVER_ID=social.near -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -curl -s "https://rpc.mainnet.fastnear.com" \ - "${AUTH_HEADER[@]}" \ +curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" \ -H 'content-type: application/json' \ --data "$(jq -nc --arg account_id "$ACCOUNT_ID" '{ jsonrpc:"2.0",id:"fastnear",method:"query", @@ -170,10 +159,8 @@ View-метод вроде `get_num` всё равно заставляет уз ```bash CONTRACT_ID=counter.near-examples.testnet -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi -RAW_B64="$(curl -s "https://rpc.testnet.fastnear.com" "${AUTH_HEADER[@]}" -H 'content-type: application/json' \ +RAW_B64="$(curl -s "https://rpc.testnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" -H 'content-type: application/json' \ --data "$(jq -nc --arg contract "$CONTRACT_ID" '{ jsonrpc:"2.0",id:"fastnear",method:"query", params:{request_type:"view_state",account_id:$contract,prefix_base64:"U1RBVEU=",finality:"final"} @@ -200,12 +187,10 @@ jq -n --arg raw "$RAW_B64" --argjson val "$DECODED_I8" '{raw_bytes_base64: $raw, ```bash ACCOUNT_ID=root.near # account you're writing under SIGNER_ACCOUNT_ID=root.near # account signing the transaction -AUTH_HEADER=() -if [ -n "${FASTNEAR_API_KEY:-}" ]; then AUTH_HEADER=(-H "Authorization: Bearer $FASTNEAR_API_KEY"); fi STORAGE_ARGS_B64="$(jq -nc --arg account_id "$ACCOUNT_ID" '{account_id:$account_id}' | base64 | tr -d '\n')" -STORAGE="$(curl -s "https://rpc.mainnet.fastnear.com" "${AUTH_HEADER[@]}" -H 'content-type: application/json' \ +STORAGE="$(curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" -H 'content-type: application/json' \ --data "$(jq -nc --arg args "$STORAGE_ARGS_B64" '{ jsonrpc:"2.0",id:"fastnear",method:"query", params:{request_type:"call_function",account_id:"social.near",method_name:"get_account_storage",args_base64:$args,finality:"final"} @@ -216,7 +201,7 @@ if [ "$SIGNER_ACCOUNT_ID" = "$ACCOUNT_ID" ]; then PERMISSION=true else PERM_ARGS_B64="$(jq -nc --arg pred "$SIGNER_ACCOUNT_ID" --arg key "$ACCOUNT_ID" '{predecessor_id:$pred,key:$key}' | base64 | tr -d '\n')" - PERMISSION="$(curl -s "https://rpc.mainnet.fastnear.com" "${AUTH_HEADER[@]}" -H 'content-type: application/json' \ + PERMISSION="$(curl -s "https://rpc.mainnet.fastnear.com?apiKey=${FASTNEAR_API_KEY:-}" -H 'content-type: application/json' \ --data "$(jq -nc --arg args "$PERM_ARGS_B64" '{ jsonrpc:"2.0",id:"fastnear",method:"query", params:{request_type:"call_function",account_id:"social.near",method_name:"is_write_permission_granted",args_base64:$args,finality:"final"} @@ -243,15 +228,13 @@ SocialDB хранит BOS-виджеты как ключи `/widget//widget/ Date: Sat, 25 Apr 2026 12:06:43 -0700 Subject: [PATCH 3/3] audit-agent-readiness-live: clarify Cloudflare-only scope This live smoke test asserts HTTP Link headers and content-negotiated .md serving advertised via static/_headers and static/_worker.js, which only execute on Cloudflare Pages with Workers/Pages Functions. Note this in a header comment so future readers know that a failure against the GitHub Pages origin is by design and not a regression. Co-Authored-By: Claude Opus 4.7 (1M context) --- scripts/audit-agent-readiness-live.js | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/scripts/audit-agent-readiness-live.js b/scripts/audit-agent-readiness-live.js index b5aceb4..24717bf 100644 --- a/scripts/audit-agent-readiness-live.js +++ b/scripts/audit-agent-readiness-live.js @@ -1,5 +1,11 @@ #!/usr/bin/env node +// Live smoke test for HTTP `Link` headers and content-negotiated `.md` serving advertised via +// `static/_headers` and `static/_worker.js`. These directives only execute on Cloudflare Pages +// with Workers/Pages Functions enabled, so this script is meaningful only against a Cloudflare +// Pages origin (production once migrated, or local `wrangler pages dev`). Against GitHub Pages +// it will fail by design — that is not a regression. Override the target with SITE_ORIGIN. + const SITE_ORIGIN = (process.env.SITE_ORIGIN || "https://docs.fastnear.com").replace(/\/+$/, ""); const API_CATALOG_FRAGMENT = 'rel="api-catalog"';