" \
https://api.goldsky.com/api/v1/subgraphs
```
Errors are returned as [RFC 9457 problem+json](https://api.goldsky.com/api/errors) — each carries a `type` URL that resolves to a human-readable explanation and a `detail` describing what to fix.
## Interactive docs & machine-readable spec
Try requests live against your project from the hosted API explorer.
The full machine-readable OpenAPI 3 spec — point your codegen, client, or agent at this URL.
## What's covered
* **Subgraphs** — deploy, list, tag, pause/resume, delete, read logs, and manage webhooks.
* **Turbo Pipelines** — create, deploy, monitor, pause/resume, and manage pipelines.
* **Edge endpoints** — manage Edge endpoints, API keys, and read metrics.
Browse them all in the [interactive API reference](https://api.goldsky.com/api/v1/docs).
# Login troubleshooting
Source: https://docs.goldsky.com/authentication-troubleshooting
If you don't see your Goldsky authentication email, try these troubleshooting steps.
Goldsky supports three sign-in methods: GitHub, Google, and email. If you're having trouble with email authentication, try the troubleshooting steps below.
## Check your spam folder
Occasionally, your provider may filter new sender emails. Check your spam or junk folder and mark it as **Not spam** if found.
## Check if you're using a shared inbox
If you're trying to sign up or log in using a shared inbox (such as `engineering@company.com`), your organization's settings may prevent external automated messages from being delivered. Try using your individual work email address instead.
## Sign in with GitHub or Google
For the easiest and fastest experience, use GitHub or Google sign-in. Both options skip the email step entirely and sign you in instantly.
## Allowlist Goldsky's domain
If you prefer to use email authentication, ask your IT or workspace administrator to allowlist our authentication domain to make sure messages arrive in your inbox.
### For Google Workspace users
If your organization uses Google Workspace:
1. Follow [Google's instructions on adding custom filters](https://support.google.com/a/answer/2368132)
2. Select the option to **Bypass spam filters and hide warnings for messages from senders or domains in selected lists**
3. Add `auth.goldsky.com` to your approved senders list
### For other email providers
Refer to your provider's documentation on allowlisting or approved senders, and add `auth.goldsky.com` as a trusted domain.
## Need help?
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Benefits
Source: https://docs.goldsky.com/benefits
Why teams build on Goldsky: Turbo pipelines, Edge RPC, Compose, Subgraphs, and platform advantages, from webhooks and instant subgraphs to faster iteration.
## Turbo
Replicate data into your own database and co-locate it with your other app data (product, customer, and any off-chain data). No brittle scraping or polling scripts, and simpler front-end queries.
Turbo supports a broad set of sinks, from OLAP databases like ClickHouse to OLTP databases like Postgres or MySQL, plus queue systems like Kafka and S2.
Ground-up Rust rewrite uses \~10x fewer resources than Mirror for the same job, and keeps up with fast chains like Solana.
Write transformation logic in TypeScript/JavaScript, watch data flow through your pipeline in real time with live inspect, and run pipelines as one-off batch jobs with a defined start and end for point-in-time pulls. Combined with faster startup times, iteration cycles are 10x faster.
Update filters on a running pipeline instantly: no restarts, no re-syncs. Track new wallets or addresses on the fly.
Access full historical Solana data from genesis (not just mid-2024 as in Mirror v1), with built-in IDL decoding.
## Edge RPC
Multi-region elastic cloud infrastructure serves requests from the closest location. A tip-of-the-chain CDN stores and serves recent blockchain data faster, while hedging mechanisms send parallel requests to multiple nodes for faster response times.
Automatic failover keeps requests flowing during provider outages. Internal scoring prioritizes the historically most reliable nodes, and multiplexing auto-merges identical requests to reduce redundant RPC calls.
Cross-validate responses from multiple RPC nodes for accuracy. Integrity mechanisms track block heights across all providers and enforce consensus checks to prevent stale, incorrect, or partial data. No more missing `eth_getLogs` results in your indexer.
Auto-split large `eth_getLogs` requests to avoid provider limits. Historical data requests are automatically routed to archive nodes, and block range enforcement guards against gaps in your data.
Sub-50ms latency from edge locations, request deduplication so multiple users share a single upstream call, graceful degradation with automatic retries and failover, and real-time data via tip-of-chain caching.
\$5 per million requests with all methods priced equally. No surprise charges for `eth_getLogs` or trace methods. Volume discounts available for usage over 100M requests/month.
## Compose
Run code in Trusted Execution Environments (TEEs) to verify operations without the latency of decentralized consensus.
Workflows complete even through failures. Retries, recovery, and state persistence are built in, so you don't write your own error handling or babysit stuck runs.
Every function call that touches external systems is logged with inputs and outputs. Step through executions in the CLI or UI to debug issues quickly and understand exactly what happened at every stage of your workflow.
Build custom data feeds with your own data sources, scopes, refresh logic, and content, rather than adapting to someone else's design decisions.
## Subgraphs
On top of the standard subgraph development experience, Goldsky adds:
1. **Webhooks**: get pushed updates when entities change instead of polling the API. Useful for realtime notifications and data synchronization.
2. **Instant subgraphs**: index contract data from a config file, no mapping code required.
3. **Tags**: point your frontend at a stable endpoint and swap the subgraph version behind it. No downtime, no stale data.
Goldsky proxies all data ingestion through a load balancer with 20+ RPC endpoints and automatically prioritizes between them based on latency, time of day, and historical responsiveness. The result: faster indexing and higher uptime than the alternatives.
On a dedicated indexing instance, Goldsky can add custom RPC endpoints for any EVM-compatible chain with no downtime, including custom or private blockchains.
Stream subgraph data into your broader infrastructure via Turbo, with control an API alone can't give you. Cross-chain subgraphs are one example.
## Platform
There's no token, so you don't run a trading desk just to pay your data provider, and no per-query fees, so costs stay predictable.
Goldsky offers 24/7 on-call support and has a team of engineering staff available to assist with debugging, issue resolution, and proactive management.
# Blog
Source: https://docs.goldsky.com/blog
News, engineering deep dives, and customer stories from Goldsky.
# Cut RPC costs with Boost
Source: https://docs.goldsky.com/boost
Keep your current RPC provider while Boost serves eligible historical reads from Goldsky's indexed data and forwards everything else upstream.
Boost reduces the traffic sent to an RPC provider you already use. Eligible historical reads come from Goldsky's indexed data. Every other JSON-RPC call forwards to your configured endpoint.
Your application keeps one RPC interface and one response shape. You keep control of the upstream provider, while repeatable reads can avoid reaching it at all.
Configure an upstream and verify your first cache hit.
Understand cache eligibility, block tags, batches, and forwarding.
## How Boost fits into your stack
1. Your application sends JSON-RPC requests to a Boost URL instead of directly to your provider.
2. Boost serves eligible reads when Goldsky has the requested historical data.
3. Calls Boost cannot serve are forwarded to the active upstream configured for that network.
The routing decision uses the request method and parameters. It does not require an additional request to your provider.
Boost preserves the JSON-RPC interface, but it is still an HTTP proxy. It normalizes some transport headers and manages CORS at the edge. See [request and response forwarding](/boost/configuration#request-and-response-forwarding) for the exact contract.
## Use Boost when
* You want to keep your current provider and client libraries.
* Your workload repeatedly reads fixed blocks, transactions, receipts, or log ranges.
* You want to reduce upstream request volume without changing application behavior on a cache miss.
* You need to measure which requests Boost served and which reached your provider.
Boost is not a replacement for WebSocket subscriptions or a way to cache chain-head queries such as `latest`. Those calls remain with your provider. If you want Goldsky to operate the RPC provider layer as well, use [Edge RPC](/edge-rpc/introduction).
## Explore Boost
Make a cache hit, compare a forwarded request, and update an existing client.
Cached methods, block tags, batch behavior, and the forwarding contract.
Provider connections, custom URLs, credentials, headers, CORS, and timeouts.
Read response headers and calculate the share of calls that avoided your provider.
Endpoint syntax, supported networks, billing, and limits.
Diagnose misses, provider errors, CORS, large batches, and verification issues.
## Getting help
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Configure Boost upstreams
Source: https://docs.goldsky.com/boost/configuration
Connect a provider account or custom RPC URL, manage credentials and fallback upstreams, and understand Boost's forwarding behavior.
Each Goldsky project has one Boost configuration and one Boost API key. For each enabled network, the configuration identifies the active upstream, provider credentials, allowed browser origins, and forwarding timeout.
## Choose a setup path
### Connect a provider account
Supply a management credential once and let Boost prepare upstreams for the networks you select. The exact action depends on the provider.
| Vendor | Credential | What Boost does |
| - | - | - |
| QuickNode | An API key with **Admin API** access from Dashboard → API Keys. Paid plans only | Creates one dedicated endpoint per network in your account |
| Alchemy | An **access key** with read-and-write **App Management** permission from Dashboard → Settings → Security. This is not an app API key | Creates one dedicated app and enables every selected network on it |
| Chainstack | A Platform API key from Console → Settings → API keys. Available on every plan; your plan's node limit still applies | Creates one project with a Global Node for each selected network |
| dRPC | A **NodeCloud Keys API** token from Settings → API Tokens. Do not use a Statistics API or NodeCore token | Reads your key list and points every selected network at an existing unrestricted key; it creates nothing in your dRPC account |
For QuickNode, Alchemy, and Chainstack, Boost only modifies resources that it created. Disconnecting deletes those resources without changing your pre-existing endpoints, apps, projects, or nodes. Disconnecting dRPC only forgets the dashboard token and removes the upstreams assembled from it; nothing in your dRPC account changes.
A dRPC key restricted by IP, browser origin, JWT, network, or method cannot serve Boost's forwarding path. Create or select an active, unrestricted key before connecting the account. Some dRPC networks require a paid plan.
### Supply an RPC URL
You can use any endpoint reachable over public HTTPS, including a node you operate or a Goldsky Edge RPC endpoint.
For each network, configure:
* An upstream RPC URL
* Any custom authentication headers required by the provider
* Optional standby upstreams
* An optional forwarding timeout
Only one upstream is active for a network at a time. Switching to a standby is an explicit configuration change, not automatic failover.
A network with no active upstream cannot serve traffic. Boost returns a JSON-RPC error instead of accepting a request it cannot forward.
## Credentials
Provider URLs and configured headers are encrypted at rest. You can replace or remove them in the dashboard.
If a URL contains user information such as `https://user:pass@example.com`, Boost converts it to an `Authorization: Basic` header before forwarding. The configured URL and headers are not written to logs, errors, or metrics.
For provider credentials that do not change per request, prefer configured headers. Your callers then need only the Goldsky key.
## Request and response forwarding
Boost preserves the JSON-RPC request body for calls sent upstream. As an HTTP proxy, it normalizes connection and transport headers on both sides of the request.
### Headers sent to your provider
Your upstream receives caller-supplied headers plus the custom headers configured on the Boost endpoint. Configured headers are applied last and win when the same name appears in both places.
Boost manages or removes these headers:
| Header | Behavior |
| - | - |
| `X-ERPC-Secret-Token` | Reserved by the edge and never forwarded |
| `Host` | Set from the upstream URL |
| `Content-Type`, `Accept` | Set to `application/json` |
| `Content-Length` | Recomputed for the forwarded request |
| `Accept-Encoding` | Set to request gzip from the provider |
| `Content-Encoding` | Removed because Boost sends an uncompressed request body |
| `Cookie`, `Proxy-Authorization` | Removed instead of relaying session credentials to a third party |
| Hop-by-hop headers | Removed because they apply to one connection only |
Other headers pass through, including `traceparent`, `tracestate`, `b3`, `baggage`, `User-Agent`, and custom `x-*` headers.
### Provider authentication headers
Put the Goldsky key in the query string:
```text theme={"dark"}
https://edge.goldsky.com/boost/{chain}?key={your-goldsky-key}
```
With the Goldsky key in the URL, request headers such as `Authorization` and `X-API-Key` can be forwarded to your provider.
Always include `?key=` when sending provider credentials as request headers. Without it, Boost cannot distinguish your provider credential from Goldsky authentication.
### Caller IP
Boost relays the complete `X-Forwarded-For` chain. The final entry is the address observed by the Goldsky load balancer. Earlier entries are caller-supplied and should be treated as untrusted.
`X-Real-IP`, `Forwarded`, `CF-Connecting-IP`, and `True-Client-IP` are relayed when the caller sends them. Boost does not set them itself.
If your provider must not receive the caller address, [contact support](/getting-support). Goldsky can disable `X-Forwarded-For` for an endpoint.
### Headers returned to your client
Provider response headers such as `Cache-Control`, `Retry-After`, `ETag`, and custom `x-*` headers return to the client.
Boost replaces or removes these response headers:
| Header | Behavior |
| - | - |
| `Content-Encoding` | Removed after Boost inflates the provider response and negotiates client compression separately |
| `Content-Type`, `Content-Length` | Set for the response Boost sends |
| `Set-Cookie` | Removed so a provider cannot set a cookie on `edge.goldsky.com` |
| `x-cache`, `x-edge-*` | Replaced with Boost's own routing and timing headers |
| `x-goldsky-*` | Removed because these are internal accounting headers |
| `Access-Control-*` | Replaced by CORS handling at the edge |
| Hop-by-hop headers | Removed because they apply to one connection only |
## Browser access and CORS
Use the endpoint's **Allowed domains** list to control browser access. Boost answers preflight requests and reflects an allowed origin. Provider CORS headers are not merged because they describe the provider's origin rather than `edge.goldsky.com`.
Credentialed browser requests using cookies or HTTP authentication are not allowed. Response headers are exposed to browser JavaScript, so applications can read `x-cache` and the other Boost headers through `fetch` or `XMLHttpRequest`.
## Provider allowlists
Boost forwards from AWS Fargate tasks in `us-east-1`, `us-west-2`, and `eu-central-1`. Tasks use addresses from each region's public AWS pool and can receive new addresses after deploys, scaling, or restarts.
There is no fixed egress IP list. Authenticate Boost with a provider credential instead of an IP allowlist. If your provider supports only IP allowlisting, [contact support](/getting-support) before relying on it.
# How Boost routes requests
Source: https://docs.goldsky.com/boost/how-it-works
Learn which JSON-RPC requests Boost can serve, which calls always forward, and how mixed batches are handled.
Boost reads the JSON-RPC method and parameters, then chooses the response source. The API key identifies your project's Boost; that project's network configuration supplies the upstream for calls that need your provider.
## Routing model
| Request | Route | Response headers |
| - | - | - |
| Eligible historical read that Goldsky can answer | CDN | `x-cache: HIT`, `x-edge-source: cache` |
| `eth_chainId` or `net_version` | Boost | `x-edge-source: static` |
| Eligible read whose data is not available | Your upstream | `x-cache: MISS`, `x-edge-source: endpoint` |
| Tagged block, write, trace, state read, or unsupported method | Your upstream | `x-cache: MISS`, `x-edge-source: endpoint` |
| Anything that would forward, when the request asks for [cache-only](#cache-only-mode) | Nobody | `x-cache: MISS`, `x-edge-source: none` |
A failed or incomplete cache lookup falls back to your upstream. A cache miss can add proxy latency, but it does not substitute a different historical result.
## Methods eligible for indexed data
| Method | Eligible when |
| - | - |
| `eth_getBlockByNumber` | The block is a concrete hexadecimal height |
| `eth_getBlockByHash` | The requested block is available in Goldsky's indexed data |
| `eth_getTransactionByHash` | The requested transaction is available in Goldsky's indexed data |
| `eth_getTransactionReceipt` | The requested receipt is available in Goldsky's indexed data |
| `eth_getLogs` | `fromBlock` and `toBlock` are concrete hexadecimal heights, or `blockHash` is set |
| `eth_getBlockReceipts` | The block is a concrete hexadecimal height |
Eligibility does not guarantee a hit. If Goldsky does not have the requested data, Boost forwards the request.
## Block tags always forward
Requests using `latest`, `pending`, `safe`, `finalized`, or `earliest` are always forwarded. The same rule applies to `eth_getLogs` when either range bound is a tag.
Your upstream is the authority on the chain head. Serving a tag from indexed data could otherwise return a block behind your provider or a block affected by a reorganization. Use a concrete hexadecimal height when you want an eligible historical read.
## Everything else forwards
Writes, traces, and state reads such as `eth_call` and `eth_getBalance` go to your configured upstream. Boost also forwards methods it does not recognize as eligible.
For a forwarded call, Boost preserves the JSON-RPC method, parameters, and ID. The result body comes from your upstream. HTTP headers are handled separately; see [request and response forwarding](/boost/configuration#request-and-response-forwarding).
## Cache-only mode
Add `cache-only=true` and Boost never contacts your upstream. Calls it can answer from Goldsky data are answered; everything that would otherwise forward returns JSON-RPC error `-32099` instead.
Use it when the forward is the cost you are avoiding. Boost itself is free, but a forwarded call still reaches the provider you pay. A backfill, a replay, or any job with a spending ceiling can run against indexed data alone and retry the gaps later.
Send it as a query parameter or a header. The two are equivalent:
```bash theme={"dark"}
curl "https://edge.goldsky.com/boost/ethereum?key=YOUR_KEY&cache-only=true" \
-X POST -H 'Content-Type: application/json' \
-d '{"jsonrpc":"2.0","id":1,"method":"eth_getTransactionReceipt","params":["0x..."]}'
```
```bash theme={"dark"}
curl "https://edge.goldsky.com/boost/ethereum?key=YOUR_KEY" \
-X POST -H 'Content-Type: application/json' \
-H 'x-boost-cache-only: true' \
-d '{"jsonrpc":"2.0","id":1,"method":"eth_getTransactionReceipt","params":["0x..."]}'
```
A refused call returns:
```json theme={"dark"}
{
"jsonrpc": "2.0",
"id": 1,
"error": {
"code": -32099,
"message": "not in Goldsky's cache, and cache-only forbade the forward to your endpoint"
}
}
```
Boost returns an error rather than an empty result on purpose. `null` already carries meaning here — `eth_getTransactionReceipt` returns `null` for a transaction that does not exist — so answering a miss with `null` would report an absence that Goldsky never verified. Repeat the call without the flag to forward it normally.
`eth_chainId` and `net_version` still answer under cache-only, because Boost synthesizes them and no provider is involved either way. Refused calls report `x-edge-source: none`: not `endpoint`, since nothing reached your upstream.
In a batch, the flag applies per item. Eligible items are served and the rest are refused individually, in one response array.
### Skip-cache
The inverse: `skip-cache=true`, or the `x-boost-skip-cache: true` header, forwards the call to your upstream without reading the cache. Use it to time your provider directly or to fetch a value the cache would otherwise answer. Statics still answer at the edge. The next call without the flag is served from cache as usual; nothing is invalidated.
Write either value as exactly `true`. `1`, `TRUE`, `yes`, and a bare flag all read as "not requested". Sending both flags on one request returns `-32600`; they contradict.
## Batch requests
Boost evaluates JSON-RPC batches per item. Eligible items can come from Goldsky data while the remaining items are sent to your upstream together in one onward batch.
* Give every item a unique `id`. JSON-RPC does not guarantee response order, so match results by ID.
* Use `x-edge-billable` as the served-item count. `x-cache` is `HIT` only when Boost serves every item in the batch.
* Keep arrays at 100 items or fewer. Larger arrays are forwarded whole without cache lookups.
For example, a batch where Boost serves 44 of 45 items reports `x-cache: MISS` and `x-edge-billable: 44`.
## Authentication and endpoint selection
The endpoint format is:
```text theme={"dark"}
https://edge.goldsky.com/boost/{chain}?key={your-api-key}
```
The chain path selects the network. The Goldsky key identifies your project's Boost, and that network's configuration selects the active upstream. Your provider URL and persistent provider credentials stay in the configuration rather than traveling in each request.
# Measure Boost traffic
Source: https://docs.goldsky.com/boost/observability
Use Boost response headers and CLI metrics to measure cache hits, forwarded requests, latency, and avoided upstream calls.
Every Boost response identifies who answered, how long Boost spent on the request, and how many request items were served without reaching your provider.
## Response headers
| Header | Values | Meaning |
| - | - | - |
| `x-cache` | `HIT`, `MISS` | `HIT` when Boost served the single call or every item in a batch; otherwise `MISS` |
| `x-edge-source` | `cache`, `static`, `endpoint`, `none` | The system that produced the response. `none` means nothing did: a [cache-only](/boost/how-it-works#cache-only-mode) request that would have forwarded |
| `x-edge-billable` | Integer | Number of request items Boost served: `1` or `0` for a single call, or the served-item count for a batch |
| `x-edge-duration-ms` | Integer | Wall-clock time Boost spent serving the request |
| `x-edge-version` | Build string | Boost build that handled the request |
| `x-edge-region` | AWS region | Edge region that handled the request, such as `us-west-2` |
The `x-edge-billable` name predates Boost's free pricing. Treat it as a served-item count, not a monetary charge.
## Single requests
For a single JSON-RPC request:
* `x-cache: HIT` and `x-edge-billable: 1` mean Boost served the call without sending it upstream.
* `x-cache: MISS` and `x-edge-billable: 0` mean the configured endpoint answered.
* `x-edge-source: static` identifies methods answered directly by the Boost edge, such as `eth_chainId`.
* `x-edge-source: none` with `x-edge-billable: 0` means a cache-only request was refused rather than forwarded. Nothing reached your provider.
## Batch requests
Read `x-edge-billable` instead of relying on `x-cache` alone. `x-cache` is `HIT` only if Boost served every item.
For a batch of 45 calls where Boost serves 44:
```text theme={"dark"}
x-cache: MISS
x-edge-billable: 44
```
The batch contains one forwarded item, so the aggregate cache header is a miss even though most calls avoided the upstream.
## Calculate an avoided-upstream rate
Count JSON-RPC items, not HTTP requests:
```text theme={"dark"}
avoided upstream rate = sum(x-edge-billable) / total JSON-RPC items
```
This rate measures calls Boost served. To estimate monetary savings, apply your provider's pricing model to those avoided calls. Providers can price methods, compute units, or plans differently, so the headers do not represent an exact dollar amount.
## CLI metrics
Fetch aggregate endpoint metrics with:
```bash theme={"dark"}
goldsky boost metrics
```
The command reports cache hits, latency, miss reasons, and provider-level statistics. See the [`goldsky boost metrics` reference](/reference/cli#boost-metrics) for its current output and options.
## What to monitor
* **Served-item rate:** The share of JSON-RPC items with `x-edge-billable` greater than zero
* **Miss reasons:** Whether calls miss because of method eligibility, block tags, unavailable data, or batch size
* **Boost duration:** `x-edge-duration-ms`, split by response source
* **Upstream errors and latency:** Requests with `x-edge-source: endpoint`, grouped by provider
If an eligible method repeatedly misses, use the [troubleshooting guide](/boost/troubleshooting#eligible-requests-keep-missing).
# Set up Boost
Source: https://docs.goldsky.com/boost/quickstart
Configure an upstream RPC provider, make a Boost request, and verify which calls avoid your provider.
This quickstart configures one upstream, makes an eligible historical read, and confirms whether Boost or your provider answered.
## Prerequisites
* A [Goldsky account](https://app.goldsky.com)
* An HTTPS RPC endpoint for a [supported Boost network](/boost/reference#supported-networks)
* A verified Goldsky organization
A verified Goldsky organization has at least one Owner, Admin, or Editor whose email uses a company domain. Generic email providers such as Gmail, Outlook, and Proton Mail do not qualify. Verification is required to use Boost.
Open [Boost in the dashboard](https://app.goldsky.com/dashboard/edge/boost). Choose one of two setup paths:
* Connect a QuickNode, Alchemy, Chainstack, or dRPC account. Boost creates dedicated resources in QuickNode, Alchemy, and Chainstack; with dRPC, it uses an unrestricted key already in your account.
* Paste an HTTPS RPC URL and any authentication headers it needs.
Enabling Boost creates one Boost API key for the project. Copy it from the Boost dashboard; the same key works across every network you enable.
Run the interactive configuration flow:
```bash theme={"dark"}
goldsky boost enable
```
The setup wizard asks for a provider account, its management credential, and the networks to enable. See the [`goldsky boost` CLI reference](/reference/cli#boost) for non-interactive provider and endpoint management commands.
Boost endpoints use this format:
```text theme={"dark"}
https://edge.goldsky.com/boost/{chain}?key={your-api-key}
```
Use a network name or chain ID. For example, `/boost/ethereum` and `/boost/1` identify the same network.
Enter your key, choose a network, and copy the generated command:
The first request for a range that has not been served recently can return `x-cache: MISS` while Boost warms the reader from storage. Run the request again before treating the method as ineligible.
Include `-i` in the curl request so the response headers are visible. A single request served by Boost looks like this:
```text theme={"dark"}
x-cache: HIT
x-edge-source: cache
x-edge-billable: 1
x-edge-duration-ms: 14
x-edge-region: us-west-2
```
`x-edge-billable` is the number of request items Boost served. The name predates Boost's free pricing; it is a count, not a charge.
Make a state read at `latest`, which remains with your provider:
```bash theme={"dark"}
curl "https://edge.goldsky.com/boost/ethereum?key=YOUR_KEY" \
-i -X POST \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":2,"method":"eth_getBalance","params":["0x0000000000000000000000000000000000000000","latest"]}'
```
A forwarded response includes:
```text theme={"dark"}
x-cache: MISS
x-edge-source: endpoint
x-edge-billable: 0
```
## Update an existing client
Change the transport URL. The rest of the client configuration stays the same.
```typescript viem theme={"dark"}
import { createPublicClient, http } from 'viem'
import { mainnet } from 'viem/chains'
const client = createPublicClient({
chain: mainnet,
transport: http('https://edge.goldsky.com/boost/ethereum?key=YOUR_KEY')
})
```
```typescript ethers.js theme={"dark"}
import { JsonRpcProvider } from 'ethers'
const provider = new JsonRpcProvider(
'https://edge.goldsky.com/boost/ethereum?key=YOUR_KEY'
)
```
```typescript web3.js theme={"dark"}
import Web3 from 'web3'
const web3 = new Web3(
'https://edge.goldsky.com/boost/ethereum?key=YOUR_KEY'
)
```
## Next steps
Check method eligibility, block-tag behavior, and batch semantics.
Turn response headers into an accurate avoided-upstream count.
# Boost reference
Source: https://docs.goldsky.com/boost/reference
Boost endpoint syntax, supported networks, billing behavior, and service limits.
## Endpoint format
```text theme={"dark"}
https://edge.goldsky.com/boost/{chain}?key={your-api-key}
```
`{chain}` accepts a path name or chain ID and is case-insensitive. For example, `/boost/ethereum` and `/boost/1` are equivalent.
The key identifies your project's Boost. The chain must be enabled and have an active upstream in that project's configuration.
### Request options
| Option | Carrier | Effect |
| - | - | - |
| `cache-only=true` | Query parameter or `x-boost-cache-only` header | Serve from Goldsky data only. Calls that would forward return `-32099`. See [cache-only mode](/boost/how-it-works#cache-only-mode) |
| `skip-cache=true` | Query parameter or `x-boost-skip-cache` header | Forward without reading the cache. See [skip-cache](/boost/how-it-works#skip-cache) |
Write the value as exactly `true`; any other value leaves the option off. Unrecognized query parameters are ignored, so your own tracking parameters pass through harmlessly.
## gRPC endpoint
Boost serves the BDS [`bds.evm.RPCQueryService`](https://github.com/blockchain-data-standards/manifesto) natively, on the same host as JSON-RPC. Point a BDS client here to skip JSON encoding entirely.
```text theme={"dark"}
https://edge.goldsky.com/boost/{package.Service}/{Method}
```
The proto fixes the path, so addressing rides gRPC metadata:
| Metadata | Required | Value |
| - | - | - |
| `x-chain` | Yes | Network path name or chain ID, such as `ethereum` or `1` |
| `x-api-key` | Yes | Your Goldsky key. You can also pass `?key=` in the path, as on the JSON-RPC hop |
| `x-boost-cache-only` | No | `true` to serve from Goldsky data only |
| `x-boost-skip-cache` | No | `true` to forward without reading the cache |
Both protocols share one routing path, one set of eligible methods, and one usage record, so everything in [how Boost routes requests](/boost/how-it-works) applies to either. Responses differ only in shape:
* A method Boost answers returns the typed BDS message. Data that does not exist returns a successful response with the data field unset, matching the proto's "null if not found" convention.
* Errors arrive as gRPC statuses: `UNIMPLEMENTED` for an unsupported method, `INVALID_ARGUMENT` for a bad parameter, `RESOURCE_EXHAUSTED` for an oversized `eth_getLogs` range, and `NOT_FOUND` for a cache-only refusal.
* Structured errors carry `bds.common.ErrorDetails` in the status details, so a cache-only refusal carries `DATA_NOT_FOUND` and an oversized range carries `RANGE_TOO_LARGE`.
* The [observability headers](/boost/observability#response-headers) arrive as initial metadata under the same names.
## Supported networks
Boost offers networks whose indexed coverage starts at genesis. Networks with a later coverage floor are excluded so the same endpoint does not unpredictably serve recent history while forwarding older ranges.
The [dashboard](https://app.goldsky.com/dashboard/edge/boost) and `goldsky boost chains` command are the live sources for availability.
Goldsky indexes additional networks that Boost does not currently offer, including Arbitrum, BNB Chain, Celo, Gnosis, Sei, Tron, and Abstract. Their indexed coverage begins above genesis.
## Billing
Boost is free to use. Goldsky does not charge for either served reads or forwarded requests. Forwarded calls still reach the RPC provider you pay separately.
Usage appears on invoices as zero-dollar line items for calls Boost served and requests it forwarded. For mixed batches, use `x-edge-billable` to count the individual items Boost served.
## Limits
* Every request needs a Goldsky `key`. A keyless request receives an [x402 payment challenge](/edge-rpc/capabilities/x402) from the shared edge rather than using Boost.
* The requested network must be enabled and have an active upstream in the project's Boost configuration.
* Upstream endpoints must be reachable over public HTTPS. Private, loopback, and link-local addresses are rejected.
* Boost supports JSON-RPC and BDS gRPC over HTTPS. There is no WebSocket endpoint; keep `eth_subscribe` and other subscriptions pointed at your provider.
* Batches can contain up to 100 items for per-item routing. Larger arrays are forwarded whole.
* Rate limits are Goldsky-managed. Boost endpoints use a Goldsky-set budget rather than a customer-configured rate-limit budget.
* Requests are unmetered within fair use. Contact Goldsky if you need a written volume commitment.
## Related reference
* [`goldsky boost` CLI commands](/reference/cli#boost)
* [Methods and routing behavior](/boost/how-it-works)
* [Cache-only mode](/boost/how-it-works#cache-only-mode)
* [Request and response headers](/boost/configuration#request-and-response-forwarding)
* [Observability headers and metrics](/boost/observability)
# Troubleshoot Boost
Source: https://docs.goldsky.com/boost/troubleshooting
Diagnose Boost cache misses, upstream errors, CORS failures, large batches, and organization verification issues.
## Common issues
| Symptom | Likely cause | What to check |
| - | - | - |
| `x-cache: MISS` on a fixed historical read | The data was not immediately available | Retry once, then confirm the method and network are eligible |
| Every request is a miss | The workload uses tags, state reads, writes, traces, or unsupported methods | Compare the request with [routing rules](/boost/how-it-works) |
| JSON-RPC error for one network | No active upstream is configured for that network | Open the network in the dashboard and activate an upstream |
| Provider returns `401` or `403` | Provider credential is missing, expired, or overridden | Check the upstream URL and configured headers |
| Browser preflight fails | The origin is not in **Allowed domains** | Add the exact browser origin to the Boost endpoint |
| A large batch never produces hits | The array contains more than 100 items | Split it into batches of 100 or fewer |
| WebSocket connection fails | Boost supports HTTPS only | Keep `wss://` and `eth_subscribe` pointed at your provider |
| Provider IP allowlist rejects Boost | Boost has no fixed egress IP list | Authenticate with a URL or header credential, or contact support |
## Provider account connections
| Provider | If connection or provisioning fails |
| - | - |
| QuickNode | Confirm the key has **Admin API** access and the account is on a paid plan |
| Alchemy | Use an account access key with read-and-write **App Management** permission, not an app API key |
| Chainstack | Use a Platform API key from Settings → API keys and check whether the plan's node limit has been reached |
| dRPC | Use the **NodeCloud Keys API** token from Settings → API Tokens, then confirm the account has an active key without IP, origin, JWT, network, or method restrictions |
Boost reports unsupported or paid-only networks on the affected row. If the connected account cannot serve a network, add a custom HTTPS RPC URL for that network instead.
## Eligible requests keep missing
Confirm all of these conditions:
1. The network appears in the [supported network list](/boost/reference#supported-networks).
2. The method appears in [methods eligible for indexed data](/boost/how-it-works#methods-eligible-for-indexed-data).
3. Block parameters are concrete hexadecimal heights rather than tags such as `latest`.
4. `eth_getLogs` uses concrete `fromBlock` and `toBlock` values or a `blockHash`.
5. A batch has no more than 100 items.
An eligible request can still miss when Goldsky does not have that specific data. The request then forwards to your upstream.
## Organization verification
Boost requires a verified Goldsky organization.
A Goldsky organization is verified when at least one current Owner, Admin, or Editor has an email on a company domain. Generic email providers such as Gmail, Outlook, and Proton Mail do not qualify. Viewers do not count toward verification.
### If your organization is not verified
Add an Owner, Admin, or Editor with an email on your company's domain, then retry.
If your organization uses a shared domain you do not control, is still setting up company accounts, or believes a domain was misclassified, contact [support@goldsky.com](mailto:support@goldsky.com) or your shared Slack channel. Include the organization ID shown in the settings URL.
If verification is temporarily unavailable, retry and contact support if the problem persists.
## Getting help
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# 0G
Source: https://docs.goldsky.com/chains/0g
0G support on Goldsky: Turbo pipelines on 0G Mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Abstract Chain
Source: https://docs.goldsky.com/chains/abstract
Abstract Chain support on Goldsky: Turbo pipelines and Subgraphs on Abstract mainnet and Abstract Testnet, plus Edge RPC and Compose on mainnet.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# ApeChain
Source: https://docs.goldsky.com/chains/apechain
ApeChain support on Goldsky: Turbo pipelines and Subgraphs on Apechain mainnet and Apechain Curtis, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Arbitrum Nova
Source: https://docs.goldsky.com/chains/arbitrum-nova
Arbitrum Nova support on Goldsky: Turbo pipelines and Subgraphs on Arbitrum Nova mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Arbitrum One
Source: https://docs.goldsky.com/chains/arbitrum-one
Arbitrum One support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Arbitrum One mainnet and Arbitrum Sepolia, with CLI setup steps.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Arc
Source: https://docs.goldsky.com/chains/arc
Arc support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Arc Mainnet and Arc Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Arena-Z
Source: https://docs.goldsky.com/chains/arena-z
Arena-Z support on Goldsky: current availability for Arena Z and Arena Z Testnet, CLI setup steps, and how to reach the team about enabling Arena-Z.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Indexing Arweave with Goldsky
Source: https://docs.goldsky.com/chains/arweave
Arweave indexing with Goldsky is coming soon. Contact support@goldsky.com if you're running into issues building on Arweave and need help meanwhile.
Coming soon. If you're running into issues building on Arweave, please contact [support@goldsky.com](mailto:support@goldsky.com) and we'd be happy to help.
# Automata Network
Source: https://docs.goldsky.com/chains/automata
Automata Network support on Goldsky: current availability, CLI setup steps, and how to reach the team about enabling Automata Network.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Avalanche
Source: https://docs.goldsky.com/chains/avalanche
Avalanche support on Goldsky: Turbo pipelines, Edge RPC, and Compose on Avalanche mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# B3
Source: https://docs.goldsky.com/chains/b3
B3 support on Goldsky: Turbo pipelines and Subgraphs on B3 mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Base
Source: https://docs.goldsky.com/chains/base
Base support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Base mainnet and Base Sepolia, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Berachain
Source: https://docs.goldsky.com/chains/berachain
Berachain support on Goldsky: Turbo pipelines and Subgraphs on Berachain Mainnet and Berachain Bepolia, plus Edge RPC and Compose on mainnet.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Bitcoin
Source: https://docs.goldsky.com/chains/bitcoin
Bitcoin support on Goldsky: Turbo pipelines on Bitcoin mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Blast
Source: https://docs.goldsky.com/chains/blast
Blast support on Goldsky: Turbo pipelines, Edge RPC, and Compose on Blast mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# BOB (Build on Bitcoin)
Source: https://docs.goldsky.com/chains/bob
BOB (Build on Bitcoin) support on Goldsky: Turbo pipelines on Build on Bitcoin (BOB) mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Boba Network
Source: https://docs.goldsky.com/chains/boba-eth
Boba Network support on Goldsky: Subgraphs on Boba ETH Mainnet and Boba Sepolia, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# BNB Smart Chain
Source: https://docs.goldsky.com/chains/bsc
BNB Smart Chain support on Goldsky: Turbo pipelines and Subgraphs on mainnet and testnet, plus Edge RPC and Compose on mainnet, with CLI setup steps.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# BitTorrent Chain
Source: https://docs.goldsky.com/chains/bttc
BitTorrent Chain support on Goldsky: Subgraphs on BitTorrent Chain (BTTC) mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Camp Network
Source: https://docs.goldsky.com/chains/camp
Camp Network support on Goldsky: Turbo pipelines on Camp Testnet, plus Subgraphs on mainnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Canton
Source: https://docs.goldsky.com/chains/canton
Canton support on Goldsky: current availability for Canton Mainnet and Canton Testnet, CLI setup steps, and how to reach the team about enabling Canton.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Celo
Source: https://docs.goldsky.com/chains/celo
Celo support on Goldsky: Turbo pipelines and Subgraphs on Celo mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Chiliz Chain
Source: https://docs.goldsky.com/chains/chiliz
Chiliz Chain support on Goldsky: Subgraphs on Chiliz mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Citrea
Source: https://docs.goldsky.com/chains/citrea
Citrea support on Goldsky: Subgraphs on Citrea Mainnet and Citrea Testnet Tangerine, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Codex
Source: https://docs.goldsky.com/chains/codex
Codex support on Goldsky: Turbo pipelines on Codex mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Conflux Espace
Source: https://docs.goldsky.com/chains/conflux-espace
Conflux Espace support on Goldsky: Turbo pipelines and Subgraphs on Conflux eSpace mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Corn
Source: https://docs.goldsky.com/chains/corn
Corn support on Goldsky: Subgraphs on Corn Testnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Cosmos EVM
Source: https://docs.goldsky.com/chains/cosmos-evm
Cosmos EVM support on Goldsky: current availability for Cosmos Evm Devnet, how to get started with the CLI, and how to reach the team about enabling Cosmos EVM.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Cronos Chain
Source: https://docs.goldsky.com/chains/cronos-zkevm
Cronos Chain support on Goldsky: Turbo pipelines and Subgraphs on Cronos zkEVM mainnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Cyber
Source: https://docs.goldsky.com/chains/cyber
Cyber support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Cyber mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# DATA Network
Source: https://docs.goldsky.com/chains/data
DATA Network support on Goldsky: Turbo pipelines and Subgraphs on DATA Network Mainnet and Data Network Aeneid (Testnet), plus Edge RPC and Compose on mainnet.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Degen
Source: https://docs.goldsky.com/chains/degen
Degen support on Goldsky: Turbo pipelines and Subgraphs on Degen mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Elysium
Source: https://docs.goldsky.com/chains/elysium
Elysium support on Goldsky: Subgraphs on Elysium Testnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Ethereal
Source: https://docs.goldsky.com/chains/ethereal
Ethereal support on Goldsky: Turbo pipelines and Subgraphs on Ethereal mainnet and Ethereal Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Ethereum
Source: https://docs.goldsky.com/chains/ethereum
Ethereum support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Ethereum mainnet and Ethereum Sepolia, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Etherlink
Source: https://docs.goldsky.com/chains/etherlink
Etherlink support on Goldsky: Turbo pipelines and Subgraphs on Etherlink mainnet and Etherlink Shadownet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Everclear
Source: https://docs.goldsky.com/chains/everclear
Everclear support on Goldsky: Subgraphs on Everclear mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Filecoin
Source: https://docs.goldsky.com/chains/filecoin
Filecoin support on Goldsky: Subgraphs on Filecoin mainnet and Filecoin Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Flare Network
Source: https://docs.goldsky.com/chains/flare
Flare Network support on Goldsky: Turbo pipelines and Subgraphs on Flare mainnet and Flare Testnet, plus Edge RPC and Compose on mainnet, with CLI setup steps.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Flow
Source: https://docs.goldsky.com/chains/flow
Flow support on Goldsky: Subgraphs on Flow Mainnet and Flow Testnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Fluent
Source: https://docs.goldsky.com/chains/fluent
Fluent support on Goldsky: Turbo pipelines and Subgraphs on Fluent mainnet and Fluent Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Flynet
Source: https://docs.goldsky.com/chains/flynet-mainnet
Flynet support on Goldsky: Turbo pipelines on Flynet Mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Fogo
Source: https://docs.goldsky.com/chains/fogo
Index and stream data from the Fogo blockchain with Goldsky Subgraphs, Turbo pipelines, Mirror, Edge RPC, and Compose. Coverage, endpoints, and quickstart.
## Overview
Goldsky is the modern back-end for crypto-enabled products; the infrastructure layer between your application and the blockchain. We handle the complex, undifferentiated work of building on crypto rails: streaming real-time data, maintaining reliable chain connectivity, and executing onchain logic. Teams use Goldsky to ship faster and stay focused on their core product.
Fogo is a purpose-built Layer 1 blockchain designed for high-performance trading with sub-40ms blocks, sub-second confirmation, and SVM L1 compatibility. Built on a custom Firedancer client, Fogo delivers the speed and reliability demanded by modern finance.
### Partnership
Goldsky has partnered with Fogo to make our product available to the ecosystem and provide dedicated support for Fogo. Below in the overview of each product, the "Partner Sponsored" tag indicates that usage of that product is fully covered by the chain, if approved by the Fogo team. Where this perk is available, please reach out to the developer relations team for an access code to the private signup form.
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
NOT COMPATIBLE
Subgraphs are designed for EVM-compatible chains and are not available for Fogo.
Fogo uses a different virtual machine architecture. For Fogo data indexing, consider using [Mirror](/mirror/introduction) or [Turbo](/turbo-pipelines/introduction) pipelines which support non-EVM chains.
## Turbo
MAINNET SUPPORTED
TESTNET SUPPORTED
Turbo pipelines provide high-performance streaming data pipelines with sub-second latency. Deploy a pipeline to start streaming Fogo data to your preferred destination.
### Available chain slugs
Mainnet: `fogo` | Testnet: `fogo_testnet`
For the full configuration reference and available transforms, see the [Turbo documentation](/turbo-pipelines/introduction).
### Working with Fogo datasets
Goldsky provides real-time streaming of Fogo datasets, including all historical data.
The following datasets are currently available:
| Dataset | Description |
| - | - |
| **Transactions with Instructions** (`fogo.raw_transactions_with_instructions`) | Enriched transaction data including instructions, accounts, balance changes, and metadata for the block. |
| **Rewards** | Records of rewards distributed to validators for securing and validating the network. |
| **Blocks** | Metadata for each block on the chain including hashes, transaction count, slot and leader rewards. |
These datasets can be used as sources in your Turbo pipelines to stream Fogo data to any of the supported sinks.
### Deploying Fogo pipelines
Turbo pipelines are defined using YAML configuration files and deployed via the Goldsky CLI. Here's the workflow:
1. **Create a pipeline configuration file**: define your sources, transforms, and sinks in a YAML file
2. **Validate your configuration**: run `goldsky turbo validate fogo-pipeline.yaml` to check for errors
3. **Deploy the pipeline**: run `goldsky turbo apply fogo-pipeline.yaml` to deploy
4. **Monitor your pipeline**: use `goldsky turbo logs fogo-pipeline.yaml` to view logs and `goldsky turbo inspect fogo-pipeline.yaml` to see live data
For a complete walkthrough, see the [Turbo Pipelines Quickstart](/turbo-pipelines/quickstart).
Remember to first create a [Secret](/platform/secrets) in order for Turbo Pipelines to be able to write the data into the database of your choice.
### Example pipeline configuration
Here's an example configuration file for streaming Fogo transactions with instructions:
```yaml fogo-transactions.yaml theme={"dark"}
name: fogo-transactions
resource_size: s
sources:
fogo_transactions:
type: dataset
dataset_name: fogo.raw_transactions_with_instructions
version: 1.0.0
start_at: latest # or 'earliest' to process all historical data
filter: block_slot >= 1000000 # Optional: only include transactions at or after this slot
sinks:
postgres_fogo_transactions:
type: postgres
from: fogo_transactions
schema: public
table: fogo_transactions
secret_name:
primary_key: id
```
**Choosing where to start:**
* **`start_at: latest`** streams data from when the pipeline is deployed. Use `start_at: earliest` instead to process all historical data.
* **`filter: block_slot >= `** limits the source to transactions at or after a specific Fogo slot. Fogo does not support a numeric `start_block`; use this slot filter for historical processing from a specific point in time.
Add your corresponding secret name and run `goldsky turbo apply fogo-transactions.yaml` to deploy the pipeline.
## Edge
NOT COMPATIBLE
Edge RPC is designed for EVM-compatible chains and is not available for Fogo.
Fogo uses a different virtual machine architecture. For Fogo data access, consider using [Mirror](/mirror/introduction) or [Turbo](/turbo-pipelines/introduction) pipelines which support non-EVM chains.
## Compose
NOT YET AVAILABLE
Compose lets you build offchain-to-onchain systems that durably move data and execute logic between your application and the blockchain. Learn more about what you can build with Compose in the [Compose documentation](/compose/introduction). Compose is not currently enabled for Fogo, but we'd love to change that.
**From the Fogo team?** [Book a call](https://cal.com/team/goldsky/website-intro) to explore enabling Compose for your ecosystem.
**Building on Fogo?** [Contact us](https://cal.com/team/goldsky/website-intro) about dedicated infrastructure options.
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Forma
Source: https://docs.goldsky.com/chains/forma
Forma support on Goldsky: Turbo pipelines on Forma mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Fraxtal
Source: https://docs.goldsky.com/chains/fraxtal
Fraxtal support on Goldsky: Turbo pipelines on Fraxtal Mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Fuse
Source: https://docs.goldsky.com/chains/fuse
Fuse support on Goldsky: Edge RPC and Compose on Fuse Mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Gensyn
Source: https://docs.goldsky.com/chains/gensyn
Gensyn support on Goldsky: Turbo pipelines and Subgraphs on Gensyn Mainnet and Gensyn Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Gnosis Chain
Source: https://docs.goldsky.com/chains/gnosis
Gnosis Chain support on Goldsky: Turbo pipelines, Edge RPC, and Compose on Gnosis mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Gravity
Source: https://docs.goldsky.com/chains/gravity
Gravity support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Gravity mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Ham
Source: https://docs.goldsky.com/chains/ham
Ham support on Goldsky: current availability for Ham, how to get started with the CLI, and how to reach the team about enabling Ham.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# HashKey
Source: https://docs.goldsky.com/chains/hashkey
HashKey support on Goldsky: Turbo pipelines on HashKey mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Hedera
Source: https://docs.goldsky.com/chains/hedera
Hedera support on Goldsky: Subgraphs on Hedera Mainnet and Hedera Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Horizen
Source: https://docs.goldsky.com/chains/horizen
Horizen support on Goldsky: Subgraphs on Horizen mainnet and Horizen Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# HyperEVM
Source: https://docs.goldsky.com/chains/hyperevm
HyperEVM support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on HyperEVM mainnet and HyperEVM Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Hyperliquid
Source: https://docs.goldsky.com/chains/hyperliquid
Hyperliquid support on Goldsky: Turbo pipelines on Hypercore Mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
Hypercore datasets start at block `846900800` (January 1, 2026). Blocks before `846900800` aren't available. See [Hypercore sources](/turbo-pipelines/sources/hypercore) for the available datasets.
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Immutable zkEVM
Source: https://docs.goldsky.com/chains/immutable-zkevm
Immutable zkEVM support on Goldsky: Turbo pipelines and Subgraphs on Immutable zkEVM mainnet and Immutable zkEVM Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Incentiv
Source: https://docs.goldsky.com/chains/incentiv
Incentiv support on Goldsky: Turbo pipelines and Subgraphs on Incentiv mainnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Injective
Source: https://docs.goldsky.com/chains/injective
Injective support on Goldsky: Turbo pipelines on Injective Mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Ink
Source: https://docs.goldsky.com/chains/ink
Ink support on Goldsky: Turbo pipelines and Subgraphs on Ink mainnet and Ink Sepolia, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Overview
Source: https://docs.goldsky.com/chains/introduction
Where Goldsky runs: the full list of supported EVM and non-EVM networks, partner chains with dedicated docs, and how to reach the team about a partnership.
## All networks
Goldsky currently supports more than 90 networks across Subgraphs and Mirror. For the full list of supported networks, click through to the dedicated reference page [here](/chains/supported-networks).
## Partner networks
Goldsky works directly with leading and emerging networks to make its indexing solutions available to the developer ecosystem. For networks, this introduces several advantages:
* enhanced developer experience for your network
* seamless porting of applications from other major chains
* industry-leading infrastructure reliability and performance
* offloaded engineering and developer success
Chain-specific documentation for each of Goldsky's partner networks is linked below. This is currently a work-in-progress, so if you are building on one of our partner networks or would like to learn more about our network partnership approach, please don't hesitate to contact us at [support@goldsky.com](mailto:support@goldsky.com) or book a call with our team.
}
href="/chains/0g"
/>
} href="/chains/abstract" />
} href="/chains/apechain" />
}
href="/chains/arc"
/>
} href="/chains/arweave" />
} href="/chains/berachain" />
} href="/chains/bob" />
} href="/chains/camp" />
} href="/chains/citrea" />
} href="/chains/filecoin" />
} href="/chains/flare" />
}
href="/chains/fluent"
/>
}
href="/chains/fogo"
/>
}
href="/chains/gensyn"
/>
}
href="/chains/horizen"
/>
}
href="/chains/incentiv"
/>
} href="/chains/ink" />
} href="/chains/iota" />
}
href="/chains/kaia"
/>
}
href="/chains/kite-ai"
/>
} href="/chains/litvm" />
} href="/chains/lumia" />
} href="/chains/manta" />
}
href="/chains/mantra"
/>
}
href="/chains/megaeth"
/>
} href="/chains/moca" />
} href="/chains/mode" />
}
href="/chains/monad"
/>
}
href="/chains/morph"
/>
}
href="/chains/near"
/>
} href="/chains/neura" />
}
href="/chains/pharos"
/>
{/* Brand-teal fill so the logo pops on a dark card */}
}
href="/chains/plasma"
/>
} href="/chains/plume" />
}
href="/chains/redbelly"
/>
} href="/chains/rise" />
} href="/chains/sei" />
} href="/chains/sophon" />
} href="/chains/stellar" />
} href="/chains/sui" />
} href="/chains/taiko" />
} href="/chains/unichain" />
} href="/chains/viction" />
}
href="/chains/zircuit"
/>
# IOTA
Source: https://docs.goldsky.com/chains/iota
IOTA support on Goldsky: Turbo pipelines on IOTA EVM Mainnet and IOTA Testnet, plus Subgraphs on mainnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Kaia
Source: https://docs.goldsky.com/chains/kaia
Kaia support on Goldsky: Turbo pipelines, Edge RPC, and Compose on Kaia Mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Katana
Source: https://docs.goldsky.com/chains/katana
Katana support on Goldsky: Turbo pipelines and Subgraphs on Katana mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Kava
Source: https://docs.goldsky.com/chains/kava
Kava support on Goldsky: Edge RPC and Compose on Kava Mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Indexing Kite AI with Goldsky
Source: https://docs.goldsky.com/chains/kite-ai
## Overview
Goldsky provides high-performance data infrastructure for Kite AI, making it easy to extract, transform, and load on-chain data to power both application and analytics use cases. Goldsky offers two primary approaches to indexing and accessing blockchain data: [Subgraphs](/subgraphs/introduction) (hosted GraphQL APIs) and [Turbo](/turbo-pipelines/introduction) (real-time data pipelines).
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
### Subgraphs
Kite AI subgraphs can be deployed on Goldsky in 2 ways:
* Via CLI from a local subgraph configuration file. If you are familiar with developing subgraphs already, you'll be familiar with this approach; after defining a subgraph locally (with a `subgraph.yaml` file, a `schema.graphql` file, and the necessary mappings to translate raw event data into the entities defined in the schema), you can deploy subgraphs to Goldsky (once the Goldsky CLI is installed) using `goldsky subgraph deploy / --path .` For more, read the [step-by-step guide](/subgraphs/deploying-subgraphs).
* Via instant subgraphs, where you can pass through a contract address and the ABI for that contract. This is a quick-start option that automatically generates the underlying subgraph configuration files on your behalf, making it easy to extract blockchain event data and serve it as an API endpoint without complex setup. Use the `--from-abi` flag in the command above instead of `--path`. For more, read the [low-code subgraphs guide](/subgraphs/guides/create-a-low-code-subgraph).
Kite AI Mainnet and Testnet are available at the chain slugs `kite-ai` and `kite-ai-testnet` respectively.
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Linea
Source: https://docs.goldsky.com/chains/linea
Linea support on Goldsky: Turbo pipelines and Subgraphs on Linea mainnet and Linea Sepolia, plus Edge RPC and Compose on mainnet, with CLI setup steps.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Lisk
Source: https://docs.goldsky.com/chains/lisk
Lisk support on Goldsky: Turbo pipelines and Subgraphs on Lisk mainnet and Lisk Sepolia, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Litecoin
Source: https://docs.goldsky.com/chains/litecoin
Litecoin support on Goldsky: Turbo pipelines on Litecoin mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# LitVM
Source: https://docs.goldsky.com/chains/litvm
LitVM support on Goldsky: Turbo pipelines and Subgraphs on LitVM Liteforge Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Lumia
Source: https://docs.goldsky.com/chains/lumia
Lumia support on Goldsky: Subgraphs on Lumia mainnet and Lumia Beam Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Derive
Source: https://docs.goldsky.com/chains/lyra
Derive support on Goldsky: Turbo pipelines on Lyra Mainnet and Lyra Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Manta Network
Source: https://docs.goldsky.com/chains/manta
Manta Network support on Goldsky: Subgraphs on Manta Pacific mainnet and Manta Pacific Sepolia, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Mantle
Source: https://docs.goldsky.com/chains/mantle
Mantle support on Goldsky: Turbo pipelines on Mantle Mainnet, plus Edge RPC, Compose, and Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# MANTRA
Source: https://docs.goldsky.com/chains/mantra
MANTRA support on Goldsky: Subgraphs on Mantra mainnet and Mantra Dukong Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# MegaETH
Source: https://docs.goldsky.com/chains/megaeth
MegaETH support on Goldsky: Turbo pipelines and Subgraphs on MegaETH mainnet and MegaETH Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Metal
Source: https://docs.goldsky.com/chains/metal
Metal support on Goldsky: Turbo pipelines on Metal mainnet and Metal Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Metis
Source: https://docs.goldsky.com/chains/metis
Metis support on Goldsky: Subgraphs on Metis mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Mezo
Source: https://docs.goldsky.com/chains/mezo
Mezo support on Goldsky: Turbo pipelines and Subgraphs on Mezo mainnet and Mezo Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Mitosis
Source: https://docs.goldsky.com/chains/mitosis
Mitosis support on Goldsky: Subgraphs on Mitosis Mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Moca Network
Source: https://docs.goldsky.com/chains/moca
Moca Network support on Goldsky: Turbo pipelines and Subgraphs on Moca Mainnet and Moca Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Mode Network
Source: https://docs.goldsky.com/chains/mode
Mode Network support on Goldsky: Turbo pipelines and Subgraphs on Mode mainnet and Mode Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Monad
Source: https://docs.goldsky.com/chains/monad
Monad support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Monad mainnet and Monad Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Moonbeam
Source: https://docs.goldsky.com/chains/moonbeam
Moonbeam support on Goldsky: Edge RPC, Compose, and Subgraphs on Moonbeam Mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Morph
Source: https://docs.goldsky.com/chains/morph
Morph support on Goldsky: Turbo pipelines on Morph mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Movement
Source: https://docs.goldsky.com/chains/movement
Movement support on Goldsky: Turbo pipelines on Movement mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# NEAR
Source: https://docs.goldsky.com/chains/near
NEAR support on Goldsky: Turbo pipelines on NEAR mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Neura
Source: https://docs.goldsky.com/chains/neura
Neura support on Goldsky: Turbo pipelines and Subgraphs on Neura Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Oasis Consensus
Source: https://docs.goldsky.com/chains/oasis-consensus
Oasis Consensus support on Goldsky: Turbo pipelines on Oasis Consensus mainnet and Oasis Consensus Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Oasis Network
Source: https://docs.goldsky.com/chains/oasis-sapphire
Oasis Network support on Goldsky: Subgraphs on Oasis Sapphire mainnet and Oasis Sapphire Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Oasys
Source: https://docs.goldsky.com/chains/oasys
Oasys support on Goldsky: current availability for Oasys Homeverse, how to get started with the CLI, and how to reach the team about enabling Oasys.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# opBNB
Source: https://docs.goldsky.com/chains/opbnb
opBNB support on Goldsky: Edge RPC and Compose on Optimism BNB (opBNB) mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Optimism
Source: https://docs.goldsky.com/chains/optimism
Optimism support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Optimism mainnet and Optimism Sepolia, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Orderly
Source: https://docs.goldsky.com/chains/orderly
Orderly support on Goldsky: Turbo pipelines and Subgraphs on Orderly mainnet and Orderly Sepolia, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Paradex
Source: https://docs.goldsky.com/chains/paradex
Paradex support on Goldsky: current availability for Paradex, how to get started with the CLI, and how to reach the team about enabling Paradex.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Pharos Network
Source: https://docs.goldsky.com/chains/pharos
Pharos Network support on Goldsky: Turbo pipelines and Subgraphs on Pharos Mainnet and Pharos Atlantic Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Plasma
Source: https://docs.goldsky.com/chains/plasma
Plasma support on Goldsky: Turbo pipelines and Subgraphs on Plasma mainnet and Plasma Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Plume Network
Source: https://docs.goldsky.com/chains/plume
Plume Network support on Goldsky: Turbo pipelines on Plume Mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Polygon PoS
Source: https://docs.goldsky.com/chains/polygon-pos
Polygon PoS support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Polygon mainnet and Polygon Amoy Testnet, with CLI setup steps.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Polygon zkEVM
Source: https://docs.goldsky.com/chains/polygon-zkevm
Polygon zkEVM support on Goldsky: Edge RPC, Compose, and Subgraphs on Polygon zkEVM mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Indexing Polymarket with Goldsky
Source: https://docs.goldsky.com/chains/polymarket
On **April 28, 2026**, Polymarket migrated to a v2 set of contracts and is no longer using subgraphs going forward. Existing public subgraph endpoints will return incomplete or incorrect data. **Turbo Pipelines** with the v2 Polymarket datasets are the recommended way to access on-chain Polymarket data.
## Overview
Goldsky provides high-performance data infrastructure for Polymarket, making it easy to extract, transform, and load on-chain data to power both application and analytics use cases via [Turbo Pipelines](/turbo-pipelines/introduction) (real-time data replication pipelines).
Polymarket is the world's largest prediction market platform, enabling users to trade on the outcome of real-world events. Built on Polygon, Polymarket processes millions of trades and provides deep liquidity for markets spanning politics, sports, economics, and more.
## Benefits
Goldsky's Polymarket integration enables:
* **Real-time market monitoring**: track order fills, matched orders, and position changes as they happen
* **Analytics and insights**: build dashboards showing open interest, trading volume, and market trends
* **User position tracking**: monitor individual user balances and positions with PnL data
* **Trading activity analysis**: analyze granular order flow and market maker activity
* **Custom alerts**: set up webhooks for specific market events or trading patterns
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
### Turbo Pipelines
Turbo pipelines allow users to replicate data into their own infrastructure (any of the [supported sinks](/turbo-pipelines/sinks)) in real time. For a complete overview of how to deploy Turbo pipelines, including a video walkthrough, check the [Quickstart guide](/turbo-pipelines/quickstart).
### Working with Polymarket datasets
Goldsky provides real-time streaming of Polymarket datasets, including all historical data.
The following datasets are currently available:
| Dataset | Description |
| - | - |
| **Order Filled (*recommended*)** | Emitted when a single Polymarket order is partially or completely filled. For example: a 50¢ YES buy for 100 YES matched against a 50¢ YES sell for 100 YES will emit 2 Order Filled events, from the perspective of the YES buy and of the YES sell. This is useful for granular tracking of trading activity and history. |
| **Orders Matched** | Emitted when a Polymarket taker order is matched against a set of Polymarket maker (limit) orders. For example: a 50¢ YES buy for 200 YES matched against 2 50¢ YES sells for 100 YES each will emit a single Orders Matched event. Orders Matched gives a more high-level view of trading activity as it only tracks taker activity. |
| **User Balances** | Keeps track of all user outcome token positions. |
| **User Positions** | Keeps track of outcome token positions along with PnL-specific data including average price and realized PnL. |
These datasets can be used as sources in your Turbo pipelines to stream Polymarket data to any of the supported sinks.
#### Dataset schemas
| Column | Type | Description |
| - | - | - |
| `id` | string | Unique event identifier |
| `block_number` | long | Block number of the event |
| `block_timestamp` | long | Unix timestamp of the block |
| `transaction_hash` | string | Transaction hash |
| `address` | string | Contract address that emitted the event |
| `user_id` | string | Address of the user whose order was filled |
| `asset` | string | Token ID of the outcome token |
| `amount_usdc` | double | USDC value of the fill |
| `amount_shares` | double | Number of outcome token shares filled |
| `price` | double | Fill price (between 0 and 1) |
| `tx_type` | string | Transaction type (e.g. `TRADE`) |
| `side` | string | Order side (`BUY` or `SELL`) |
| `order_hash` | string | Hash of the order |
| `counterparty_id` | string | Address of the counterparty |
| `order_type` | string | Whether this order was `maker` or `taker` |
| `fee` | double | Fee paid for this fill |
| `builder` | string | Builder address if applicable |
| Column | Type | Description |
| - | - | - |
| `id` | string | Unique event identifier |
| `block_number` | long | Block number of the event |
| `block_timestamp` | long | Unix timestamp of the block |
| `transaction_hash` | string | Transaction hash |
| `address` | string | Contract address that emitted the event |
| `user_id` | string | Address of the taker |
| `asset` | string | Token ID of the outcome token |
| `amount_usdc` | double | Total USDC value of the matched trade |
| `amount_shares` | double | Total number of outcome token shares matched |
| `price` | double | Effective price (between 0 and 1) |
| `tx_type` | string | Transaction type (e.g. `TRADE`) |
| `side` | string | Taker order side (`BUY` or `SELL`) |
| `order_hash` | string | Hash of the taker order |
| Column | Type | Description |
| - | - | - |
| `id` | string | Unique balance record identifier |
| `owner_address` | string | Address of the token holder |
| `contract_address` | string | ERC-1155 contract address |
| `token_id` | string | Outcome token ID |
| `token_type` | string | Token standard (e.g. `ERC_1155`) |
| `block_number` | long | Block number of the last update |
| `block_timestamp` | long | Unix timestamp of the last update |
| `balance` | decimal | Current token balance |
| Column | Type | Description |
| - | - | - |
| `user_id` | string | Address of the user |
| `token_id` | string | Outcome token ID |
| `amount` | string | Current position size |
| `avg_price` | string | Average entry price |
| `realized_pnl` | string | Realized profit and loss |
| `total_bought` | string | Total amount bought |
| `last_block` | long | Block number of the last update |
| `last_log_index` | int | Log index of the last update |
| `last_updated_at` | long | Unix timestamp of the last update |
#### Deploying Polymarket pipelines
Turbo pipelines are defined using YAML configuration files and deployed via the Goldsky CLI. Here's the workflow:
1. **Create a pipeline configuration file**: define your sources, transforms, and sinks in a YAML file
2. **Validate your configuration**: run `goldsky turbo validate polymarket-pipeline.yaml` to check for errors
3. **Deploy the pipeline**: run `goldsky turbo apply polymarket-pipeline.yaml` to deploy
4. **Monitor your pipeline**: use `goldsky turbo logs polymarket-pipeline.yaml` to view logs and `goldsky turbo inspect polymarket-pipeline.yaml` to see live data
For a complete walkthrough, see the [Turbo Pipelines Quickstart](/turbo-pipelines/quickstart).
Remember to first create a [Secret](/platform/secrets) in order for Turbo Pipelines to be able to write the data into the database of your choice. For webhook sinks, you can include authentication headers directly in the configuration.
#### Example pipeline configuration
Here's an example configuration file for streaming Polymarket order fills to a webhook endpoint, using the v2 dataset and a block number range to backfill a specific period:
```yaml polymarket-orders-webhook.yaml theme={"dark"}
name: polymarket-orders-webhook
resource_size: s
sources:
order_filled:
type: dataset
dataset_name: polymarket.order_filled
version: 2.0.0
start_at: earliest
filter: block_number >= 42598795 AND block_number <= 42835303
transforms:
high_value_orders:
type: sql
primary_key: id
sql: |
SELECT
id,
block_number,
block_timestamp,
transaction_hash,
user_id,
asset,
side,
price,
amount_usdc,
amount_shares
FROM order_filled
WHERE amount_usdc > 1000
sinks:
webhook_alerts:
type: webhook
from: high_value_orders
url: https://api.example.com/polymarket/orders
one_row_per_request: true
headers:
Authorization: Bearer YOUR_API_TOKEN
Content-Type: application/json
```
This pipeline:
1. Streams Order Filled events from the v2 Polymarket dataset for a specific block range
2. Filters for high-value orders (amount\_usdc > 1000)
3. Sends each order individually to your webhook endpoint with authentication
Deploy the pipeline by running:
```bash theme={"dark"}
goldsky turbo apply polymarket-orders-webhook.yaml
```
Fast scan is supported on the v2 Polymarket datasets, so you can backfill a specific period using a `block_number` range filter as shown above. Filtering by timestamp is not supported for fast scan; use `block_number` instead.
***Note***:
The datasets output large amounts of data. E.g. user positions may be up to 1.2B entities to backfill, and up to 150M entities monthly to maintain.
For insights on costs for datasets, please refer to our [pricing calculator](https://goldsky.com/pricing#pricing-calculator).
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Public Goods Network
Source: https://docs.goldsky.com/chains/publicgoods
Public Goods Network support on Goldsky: Turbo pipelines on Public Goods Network mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# PulseChain
Source: https://docs.goldsky.com/chains/pulsechain
PulseChain support on Goldsky: Subgraphs on PulseChain mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# RACE
Source: https://docs.goldsky.com/chains/race
RACE support on Goldsky: Turbo pipelines on Race mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# RARI Chain
Source: https://docs.goldsky.com/chains/rari
RARI Chain support on Goldsky: Subgraphs on RARI Chain mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Redbelly
Source: https://docs.goldsky.com/chains/redbelly
Redbelly support on Goldsky: Subgraphs on Redbelly mainnet and Redbelly Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Redstone
Source: https://docs.goldsky.com/chains/redstone
Redstone support on Goldsky: Turbo pipelines on Redstone mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Reya Network
Source: https://docs.goldsky.com/chains/reya
Reya Network support on Goldsky: Turbo pipelines on Reya mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# RISE Chain
Source: https://docs.goldsky.com/chains/rise
RISE Chain support on Goldsky: Turbo pipelines and Subgraphs on Rise Mainnet and Rise Sepolia, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Robinhood Chain
Source: https://docs.goldsky.com/chains/robinhood-chain
Robinhood Chain support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Robinhood Chain Mainnet and Robinhood Chain Testnet.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Ronin
Source: https://docs.goldsky.com/chains/ronin
Ronin support on Goldsky: Turbo pipelines and Subgraphs on Ronin mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Rootstock (RSK)
Source: https://docs.goldsky.com/chains/rootstock
Rootstock (RSK) support on Goldsky: Turbo pipelines and Subgraphs on Rootstock mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Indexing Saga EVM with Goldsky
Source: https://docs.goldsky.com/chains/saga
## Overview
Goldsky provides high-performance data infrastructure for Saga, making it easy to extract, transform, and load on-chain data to power both application and analytics use cases. Goldsky offers two primary approaches to indexing and accessing blockchain data: [Subgraphs](/subgraphs/introduction) (hosted GraphQL APIs) and [Turbo](/turbo-pipelines/introduction) (real-time data pipelines).
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
### Subgraphs
Saga EVM Subgraphs can be deployed on Goldsky in 2 ways:
* Via CLI from a local subgraph configuration file. If you are familiar with developing subgraphs already, you'll be familiar with this approach; after defining a subgraph locally (with a `subgraph.yaml` file, a `schema.graphql` file, and the necessary mappings to translate raw event data into the entities defined in the schema), you can deploy subgraphs to Goldsky (once the Goldsky CLI is installed) using `goldsky subgraph deploy / --path .` For more, read the [step-by-step guide](/subgraphs/deploying-subgraphs).
* Via instant subgraphs, where you can pass through a contract address and the ABI for that contract. This is a quick-start option that automatically generates the underlying subgraph configuration files on your behalf, making it easy to extract blockchain event data and serve it as an API endpoint without complex setup. Use the `--from-abi` flag in the command above instead of `--path`. For more, read the [low-code subgraphs guide](/subgraphs/guides/create-a-low-code-subgraph).
Saga EVM Pegasus Mainnet is available at the chain slug `saga-evm`.
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Scroll
Source: https://docs.goldsky.com/chains/scroll
Scroll support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Scroll Mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Sei
Source: https://docs.goldsky.com/chains/sei
Sei support on Goldsky: Turbo pipelines, Edge RPC, and Compose on Sei mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Settlus
Source: https://docs.goldsky.com/chains/settlus
Settlus support on Goldsky: Turbo pipelines on Settlus mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Shape Network
Source: https://docs.goldsky.com/chains/shape
Shape Network support on Goldsky: Turbo pipelines and Subgraphs on Shape mainnet and Shape Sepolia, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# SKALE
Source: https://docs.goldsky.com/chains/skale-calypso
SKALE support on Goldsky: Subgraphs on SKALE Calypso mainnet and SKALE Calypso Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# SNAXchain
Source: https://docs.goldsky.com/chains/snaxchain
SNAXchain support on Goldsky: current availability for Snaxchain, how to get started with the CLI, and how to reach the team about enabling SNAXchain.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Solana
Source: https://docs.goldsky.com/chains/solana
Solana support on Goldsky: Turbo pipelines on Solana mainnet and Solana Devnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Somnia
Source: https://docs.goldsky.com/chains/somnia
Somnia support on Goldsky: Edge RPC and Compose on Somnia Testnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Soneium
Source: https://docs.goldsky.com/chains/soneium
Soneium support on Goldsky: Turbo pipelines and Subgraphs on Soneium mainnet and Soneium Minato, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Sonic
Source: https://docs.goldsky.com/chains/sonic
Sonic support on Goldsky: Turbo pipelines, Edge RPC, and Compose on Sonic mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Sophon
Source: https://docs.goldsky.com/chains/sophon
Sophon support on Goldsky: Turbo pipelines and Subgraphs on Sophon mainnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Stable
Source: https://docs.goldsky.com/chains/stable
Stable support on Goldsky: Turbo pipelines on Stable Mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Starknet
Source: https://docs.goldsky.com/chains/starknet
Starknet support on Goldsky: Turbo pipelines on Starknet mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Stellar
Source: https://docs.goldsky.com/chains/stellar
## Overview
### Partnership
Goldsky has partnered with Stellar to make our product available to the ecosystem and provide dedicated support for Stellar. Below in the overview of each product, the "Partner Sponsored" tag indicates that usage of that product is fully covered by the chain, if approved by the Stellar team. Where this perk is available, please reach out to the developer relations team for an access code to the private signup form.
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Turbo
MAINNET SUPPORTED
TESTNET SUPPORTED
Turbo pipelines provide high-performance streaming data pipelines with sub-second latency. Deploy a pipeline to start streaming Stellar data to your preferred destination.
### Quick config
```yaml stellar-transactions.yaml theme={"dark"}
name: my-stellar-transactions
resource_size: s
sources:
stellar_transactions:
type: dataset
dataset_name: stellar_mainnet.transactions
version: 1.2.0
start_at: latest
sinks:
my_sink:
type: postgres
from: stellar_transactions
schema: public
table: stellar_transactions
secret_name: MY_POSTGRES_SECRET
primary_key: transaction_hash
```
Deploy with:
```bash theme={"dark"}
goldsky turbo apply stellar-transactions.yaml
```
### Available chain slugs
Mainnet: `stellar_mainnet` | Testnet: `stellar_testnet`
Goldsky provides real-time (under 5 seconds) streaming of Stellar datasets, including all historical data, for both mainnet and testnet. Datasets include ledgers, transactions, operations, events, transfers, ledger entries, and balances.
The Stellar testnet is frequently reset (typically about once every third month). We recommend deploying testnet pipelines with `start_at: latest` so they always index from the most recent testnet version.
For available datasets, schemas, version details, and pipeline examples, see the [Stellar Turbo Sources](/turbo-pipelines/sources/stellar) guide.
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Sui
Source: https://docs.goldsky.com/chains/sui
Sui support on Goldsky: stream Sui events with Turbo pipelines from the raw events dataset, with chain slugs and an example pipeline configuration.
## Overview
Goldsky is the modern back-end for crypto-enabled products; the infrastructure layer between your application and the blockchain. We handle the complex, undifferentiated work of building on crypto rails: streaming real-time data, maintaining reliable chain connectivity, and executing onchain logic. Teams use Goldsky to ship faster and stay focused on their core product.
### Partnership
Goldsky has partnered with Sui to make our product available to the ecosystem and provide dedicated support for Sui. Below in the overview of each product, the "Partner Sponsored" tag indicates that usage of that product is fully covered by the chain, if approved by the Sui team. Where this perk is available, please reach out to the developer relations team for an access code to the private signup form.
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
NOT COMPATIBLE
Subgraphs are designed for EVM-compatible chains and are not available for Sui.
Sui uses a different virtual machine architecture. For Sui data indexing, use [Turbo](/turbo-pipelines/introduction) pipelines, which support Sui datasets.
## Turbo
MAINNET SUPPORTED
Turbo pipelines provide high-performance streaming data pipelines with sub-second latency. Deploy a pipeline to start streaming Sui data to your preferred destination.
### Available chain slugs
Mainnet: `sui`
### Working with Sui datasets
Goldsky provides real-time streaming of Sui datasets, including all historical data.
The following dataset is currently available:
| Dataset | Description |
| - | - |
| **Raw Events** (`sui.raw_events_v5`) | Move contract events emitted on Sui, including event type, module, package, transaction context, and payload. |
This dataset can be used as a source in your Turbo pipelines to stream Sui data to any of the supported sinks.
### Deploying Sui pipelines
Turbo pipelines are defined using YAML configuration files and deployed via the Goldsky CLI. Here's the workflow:
1. **Create a pipeline configuration file**: define your sources, transforms, and sinks in a YAML file
2. **Validate your configuration**: run `goldsky turbo validate sui-pipeline.yaml` to check for errors
3. **Deploy the pipeline**: run `goldsky turbo apply sui-pipeline.yaml` to deploy
4. **Monitor your pipeline**: use `goldsky turbo logs sui-pipeline.yaml` to view logs and `goldsky turbo inspect sui-pipeline.yaml` to see live data
For a complete walkthrough, see the [Turbo Pipelines Quickstart](/turbo-pipelines/quickstart).
Remember to first create a [Secret](/platform/secrets) in order for Turbo Pipelines to be able to write the data into the database of your choice.
### Example pipeline configuration
Here's an example configuration file for streaming Sui raw events:
```yaml sui-events.yaml theme={"dark"}
name: sui-events
resource_size: s
sources:
sui_events:
type: dataset
dataset_name: sui.raw_events_v5
version: 1.0.0
start_at: latest # or 'earliest' to process all historical data
filter: checkpoint >= 1000000 # Optional: only include events at or after this checkpoint
sinks:
postgres_sui_events:
type: postgres
from: sui_events
schema: public
table: sui_events
secret_name:
primary_key: id
```
**Choosing where to start:**
* **`start_at: latest`** streams data from when the pipeline is deployed. Use `start_at: earliest` instead to process all historical data.
* **`filter: checkpoint >= `** limits the source to events at or after a specific Sui checkpoint. Sui does not support a numeric `start_block`; use this checkpoint filter for historical processing from a specific point in time.
Add your corresponding secret name and run `goldsky turbo apply sui-events.yaml` to deploy the pipeline.
## Edge
NOT COMPATIBLE
Edge RPC is designed for EVM-compatible chains and is not available for Sui.
Sui uses a different virtual machine architecture. For Sui data access, use [Turbo](/turbo-pipelines/introduction) pipelines, which support Sui datasets.
## Compose
NOT YET AVAILABLE
Compose lets you build offchain-to-onchain systems that durably move data and execute logic between your application and the blockchain. Learn more about what you can build with Compose in the [Compose documentation](/compose/introduction). Compose is not currently enabled for Sui, but we'd love to change that.
**From the Sui team?** [Book a call](https://cal.com/team/goldsky/website-intro) to explore enabling Compose for your ecosystem.
**Building on Sui?** [Contact us](https://cal.com/team/goldsky/website-intro) about dedicated infrastructure options.
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Superseed
Source: https://docs.goldsky.com/chains/superseed
Superseed support on Goldsky: Turbo pipelines and Subgraphs on Superseed mainnet and Superseed Sepolia, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Supported networks
Source: https://docs.goldsky.com/chains/supported-networks
Every chain Goldsky supports and which products cover it: a filterable Turbo, Edge RPC, Compose, and Subgraphs coverage matrix plus Turbo datasets by chain.
Goldsky supports 150+ networks. The matrix shows which products support each chain. Filter by name or chain ID, or use `?chain=` to deep-link to a row.
Not sure which product you need? See [Which product do I need?](/which-product)
## Coverage matrix
The same coverage as a plain table:
Support marks: **M** = mainnet, **M+T** = mainnet and testnet, **T** = testnet only, — = not supported. Chain ID is shown as mainnet / testnet where known.
### EVM & EVM-compatible
| Chain | Chain ID | Turbo | Edge RPC | Compose | Subgraphs |
| - | - | - | - | - | - |
| 0G | 16661 / 16602 | M | — | — | M+T |
| Abstract Chain | 2741 / 11124 | M+T | M | M | M+T |
| ApeChain | 33139 / 33111 | M+T | — | — | M+T |
| Arbitrum Nova | 42170 | M | — | — | M |
| Arbitrum One | 42161 / 421614 | M+T | M+T | M+T | M+T |
| Arc | 5042 / 5042002 | M+T | M+T | M+T | M+T |
| Arena-Z | — | — | — | — | — |
| Automata Network | — | — | — | — | — |
| Avalanche | 43114 / 43113 | M | M | M | M+T |
| B3 | 8333 / 1993 | M | — | — | M |
| Base | 8453 / 84532 | M+T | M+T | M+T | M+T |
| Berachain | 80094 / 80069 | M+T | M | M | M+T |
| BitTorrent Chain | 199 | — | — | — | M |
| Blast | 81457 / 168587773 | M | M | M | M+T |
| BNB Smart Chain | 56 / 97 | M+T | M | M | M+T |
| BOB (Build on Bitcoin) | 60808 / 808813 | M | — | — | M+T |
| Boba Network | 288 / 28882 | — | — | — | M+T |
| Camp Network | 484 / 90354 | T | — | — | M |
| Canton | — | — | — | — | — |
| Celo | 42220 | M | — | — | M |
| Chiliz Chain | 88888 | — | — | — | M |
| Citrea | 4114 / 5115 | — | — | — | M+T |
| Codex | 81224 | M | — | — | — |
| Conflux Espace | 1030 | M | — | — | M |
| Corn | 21000000 / 21000001 | — | — | — | T |
| Cosmos EVM | — / 4231 | — | — | — | — |
| Cronos Chain | 388 / 282 | M | — | — | M |
| Cyber | 7560 | M | M | M | M |
| DATA Network | 1514 / 1315 | M+T | M | M | M+T |
| Degen | 666666666 | M | — | — | M |
| Derive | 957 | M+T | — | — | — |
| Elysium | — / 99801 | — | — | — | T |
| Ethereal | 5064014 / 13374202 | M+T | — | — | M+T |
| Ethereum | 1 / 11155111 | M+T | M+T | M+T | M+T |
| Etherlink | 42793 / 127823 | M+T | — | — | M+T |
| Everclear | 25327 | — | — | — | M |
| Filecoin | 314 / 314159 | — | — | — | M+T |
| Flare Network | 14 / 114 | M+T | M | M | M+T |
| Flow | 747 / 545 | — | — | — | M+T |
| Fluent | 25363 / 20994 | M+T | — | — | M+T |
| Flynet | — | M | — | — | — |
| Forma | 984122 | M | — | — | — |
| Fraxtal | 252 / 2522 | M | — | — | M+T |
| Fuse | 122 | — | M | M | — |
| Gensyn | 685689 / 685685 | M+T | — | — | M+T |
| Gnosis Chain | 100 / 10200 | M | M | M | M+T |
| Gravity | 1625 | M | M | M | M |
| Ham | — | — | — | — | — |
| HashKey | 177 | M | — | — | — |
| Hedera | 295 / 296 | — | — | — | M+T |
| Horizen | 26514 / 2651420 | — | — | — | M+T |
| HyperEVM | 999 / 998 | M+T | M+T | M+T | M+T |
| Hyperliquid | — | M | — | — | — |
| Immutable zkEVM | 13371 / 13473 | M+T | — | — | M+T |
| Incentiv | 24101 / 28802 | M | — | — | M |
| Injective | — | M | — | — | — |
| Ink | 57073 / 763373 | M+T | — | — | M+T |
| IOTA | 8822 | M+T | — | — | M |
| Kaia | 8217 / 1001 | M | M | M | M+T |
| Katana | 747474 | M | — | — | M |
| Kava | 2222 / 2221 | — | M | M | M+T |
| Kite AI | 2366 / 2368 | — | — | — | M+T |
| Linea | 59144 / 59141 | M+T | M | M | M+T |
| Lisk | 1135 / 4202 | M+T | — | — | M+T |
| LitVM | — / 4441 | T | — | — | T |
| Lumia | 994873017 / 2030232745 | — | — | — | M+T |
| Manta Network | 169 / 3441006 | — | — | — | M+T |
| Mantle | 5000 / 5003 | M | M+T | M+T | M+T |
| MANTRA | 5888 / 5887 | — | — | — | M+T |
| MegaETH | 4326 / 6343 | M+T | — | — | M+T |
| Metal | 1750 / 1740 | M+T | — | — | — |
| Metis | 1088 | — | — | — | M |
| Mezo | 31612 / 31611 | M+T | — | — | M+T |
| Mitosis | 124816 | — | — | — | M |
| Moca Network | 2288 / 222888 | M+T | — | — | M+T |
| Mode Network | 34443 / 919 | M+T | — | — | M+T |
| Monad | 143 / 10143 | M+T | M+T | M+T | M+T |
| Moonbeam | 1284 | — | M | M | M |
| Morph | 2818 / 2910 | M | — | — | M+T |
| Neura | — / 267 | T | — | — | T |
| Oasis Consensus | — | M+T | — | — | — |
| Oasis Network | 23294 / 23295 | — | — | — | M+T |
| Oasys | — | — | — | — | — |
| opBNB | 204 / 5611 | — | M | M | M+T |
| Optimism | 10 / 11155420 | M+T | M+T | M+T | M+T |
| Orderly | 291 / 4460 | M+T | — | — | M+T |
| Paradex | — | — | — | — | — |
| Pharos Network | 1672 / 688689 | M+T | — | — | M+T |
| Plasma | 9745 / 9746 | M+T | — | — | M+T |
| Plume Network | 98866 / 98867 | M | — | — | M+T |
| Polygon PoS | 137 / 80002 | M+T | M+T | M+T | M+T |
| Polygon zkEVM | 1101 | — | M | M | M |
| Polymarket | — | M | — | — | — |
| Public Goods Network | 424 / 58008 | M | — | — | M+T |
| PulseChain | 369 | — | — | — | M |
| RACE | — | M | — | — | — |
| RARI Chain | 1380012617 | — | — | — | M |
| Redbelly | 151 / 153 | — | — | — | M+T |
| Redstone | — | M | — | — | — |
| Reya Network | 1729 / 89346162 | M | — | — | M+T |
| RISE Chain | 4153 / 11155931 | M+T | — | — | M+T |
| Robinhood Chain | 4663 / 46630 | M+T | M+T | M+T | M+T |
| Ronin | 2020 | M | — | — | M |
| Rootstock (RSK) | 30 | M | — | — | M |
| Scroll | 534352 / 534351 | M | M | M | M |
| Sei | 1329 / 1328 | M | M | M | M+T |
| Settlus | 5371 | M | — | — | — |
| Shape Network | 360 / 11011 | M+T | — | — | M+T |
| SKALE | 1564830818 / 974399131 | — | — | — | M+T |
| SNAXchain | — | — | — | — | — |
| Somnia | — / 50312 | — | T | T | — |
| Soneium | 1868 / 1946 | M+T | — | — | M+T |
| Sonic | 146 / 57054 | M | M | M | M+T |
| Sophon | 50104 / 531050104 | M | — | — | M |
| Stable | 988 / 2201 | M | — | — | M+T |
| Superseed | 5330 / 53302 | M+T | — | — | M+T |
| Swan Chain | — | M | — | — | — |
| Taiko | 167000 / 167013 | T | — | — | M+T |
| Telos EVM | 40 / 41 | — | — | — | M |
| Tempo | 4217 / 42431 | M+T | M+T | M+T | M+T |
| Tenet | 1559 | — | — | — | — |
| The Binary Holdings | — | — | — | — | — |
| ThunderCore | 108 / 18 | — | — | — | M+T |
| Treasure | 61166 | — | — | — | — |
| Unichain | 130 / 1301 | M+T | M+T | M+T | M+T |
| Vana | 1480 / 14800 | — | — | — | M+T |
| Viction | 88 / 89 | M | — | — | M+T |
| Volmex Finance | — / 5633311 | — | — | — | — |
| World Chain | 480 / 4801 | M | — | — | M+T |
| X Layer | 196 | M | — | — | M |
| XDC Network | 50 | — | — | — | M |
| XPLA | — | M | — | — | — |
| XRADERS | — / 2730 | — | — | — | — |
| XRPL EVM Sidechain | 1440000 / 1449000 | — | — | — | M+T |
| Xterio | — | — | — | — | — |
| Zenith | — / 936485 | T | — | — | — |
| Zero | 543210 / 4457845 | — | — | — | — |
| Zircuit | 48900 / 48898 | — | — | — | M+T |
| zkLink Nova | 810180 / 810181 | — | — | — | M |
| zkSync Era | 324 / 300 | M | M | M | M+T |
| Zora | 7777777 / 999999999 | M+T | M | M | M+T |
### Solana (SVM)
| Chain | Chain ID | Turbo | Edge RPC | Compose | Subgraphs |
| - | - | - | - | - | - |
| Fogo | — | M+T | — | — | — |
| Solana | — | M+T | — | — | — |
### Bitcoin
| Chain | Chain ID | Turbo | Edge RPC | Compose | Subgraphs |
| - | - | - | - | - | - |
| Bitcoin | — | M | — | — | — |
| Litecoin | — | M | — | — | — |
### Move
| Chain | Chain ID | Turbo | Edge RPC | Compose | Subgraphs |
| - | - | - | - | - | - |
| Movement | — | M | — | — | — |
| Sui | — | M | — | — | — |
### Other
| Chain | Chain ID | Turbo | Edge RPC | Compose | Subgraphs |
| - | - | - | - | - | - |
| Arweave | — | M | — | — | — |
| NEAR | — | M | — | — | — |
| Starknet | — | M | — | — | — |
| Stellar | — | M+T | — | — | — |
| TRON | 728126428 | M | — | — | — |
Every chain in the matrix has its own page under **Partners** and **Other networks** in the sidebar. Seven partner chains have extended, hand-written walkthroughs: [Arweave](/chains/arweave), [Fogo](/chains/fogo), [Kite AI](/chains/kite-ai), [Polymarket](/chains/polymarket), [Saga](/chains/saga), [Stellar](/chains/stellar), and [Sui](/chains/sui).
## Turbo datasets by chain
[Turbo pipelines](/turbo-pipelines/introduction) stream the datasets below into your own infrastructure. Turbo is also the only product with non-EVM sources: [Solana](/turbo-pipelines/sources/solana) (full history from genesis), [Bitcoin](/turbo-pipelines/sources/bitcoin), [Stellar](/turbo-pipelines/sources/stellar), [NEAR](/turbo-pipelines/sources/near), [Movement](/turbo-pipelines/sources/movement), and [Hypercore](/turbo-pipelines/sources/hypercore) (from block 846900800, January 1, 2026).
### EVM chains
For EVM chains we support the following 4 datasets:
| Dataset | Description |
| - | - |
| Blocks | Metadata for each block on the chain including hashes, transaction count, difficulty, and gas used. |
| Logs | Raw logs for events emitted from contracts. Contains the contract address, data, topics, and metadata for blocks and transactions. |
| Enriched Transactions | Transaction data including input, value, from and to address, and metadata for the block, gas, and receipts. |
| Traces | Traces of all function calls made on the chain including metadata for block, trace, transaction, and gas. |
### Fast Scan
Some datasets have support for [Fast Scan](/turbo-pipelines/sources/evm#fast-scan) which allows you to more quickly backfill filtered data. If a chain has partial support for Fast Scan, the dataset that doesn't support fast scan will have an asterisk `*` next to it.
Here's a breakdown of the EVM chains we support and their corresponding datasets:
| | Blocks | Enriched Transactions | Logs | Traces | Fast Scan |
| - | - | - | - | - | - |
| 0G | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Abstract | ✓ | ✓ | ✓ | ✗ | ✓ |
| Abstract Testnet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Apechain | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Apechain Curtis | ✓ | ✓ | ✓ | ✗ | ✓ |
| Arbitrum Nova | ✓ | ✓ | ✓ | ✗ | ✓ |
| Arbitrum One | ✓ | ✓ | ✓ | ✓ | ✓ |
| Arbitrum Sepolia | ✓ | ✓ | ✓ | ✗ | ✓ |
| Arc | ✓ | ✓ | ✓ | ✓ | ✓ |
| Arc Testnet | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Arweave | ✓ | ✓ | ✗ | ✗ | ✗ |
| Avalanche | ✓ | ✓ | ✓ | ✓ | ✓ |
| B3 | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Base | ✓ | ✓ | ✓ | ✓ | ✓ |
| Base Sepolia | ✓ | ✓ | ✓ | ✓ | ✓ |
| Berachain | ✓\* | ✓ | ✓ | ✓\* | ✓ |
| Berachain Bepolia | ✓ | ✓ | ✓ | ✓ | ✗ |
| Bitcoin | ✓ | ✓ | ✗ | ✗ | ✓ |
| Blast | ✓ | ✓ | ✓ | ✓ | ✓ |
| BNB Chain (BSC) | ✓ | ✓ | ✓ | ✓ | ✓ |
| BNB Chain Chapel (BSC Testnet) | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Build on Bitcoin (BOB) | ✓ | ✓\* | ✓ | ✓ | ✓ |
| Camp Testnet | ✓ | ✓ | ✓ | ✓ | ✓ |
| Celo | ✓ | ✓ | ✓ | ✓ | ✓ |
| Codex | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Conflux eSpace | ✓ | ✓ | ✓ | ✗ | ✓ |
| Cronos zkEVM | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Cyber | ✓ | ✓ | ✓ | ✓ | ✓ |
| DATA Network | ✓ | ✓ | ✓ | ✓ | ✓ |
| Data Network Aeneid (Testnet) | ✓ | ✓ | ✓ | ✓ | ✓ |
| Degen | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Echelon Cosmos | ✓ | ✓ | ✓ | ✗ | ✓ |
| Echelon Testnet Cosmos | ✓ | ✓ | ✓ | ✗ | ✓ |
| Ethereal | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Ethereal Testnet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Ethereum | ✓ | ✓ | ✓ | ✓ | ✓ |
| Ethereum Hoodi | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Ethereum Sepolia | ✓ | ✓\* | ✓ | ✓ | ✓ |
| Etherlink | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Etherlink Shadownet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Fantom | ✓ | ✓ | ✓ | ✓ | ✓ |
| Flare | ✓ | ✓ | ✓ | ✗ | ✓ |
| Flare Testnet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Fluent | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Fluent Testnet | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Flynet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Forma | ✓ | ✓ | ✓ | ✓ | ✓ |
| Fraxtal | ✓ | ✓ | ✓ | ✓ | ✓ |
| Gensyn | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Gensyn Testnet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Gnosis | ✓ | ✓ | ✓ | ✓ | ✓ |
| Gravity | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| HashKey | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Helix Test | ✓ | ✓ | ✓ | ✗ | ✗ |
| HyperEVM | ✓ | ✓ | ✓ | ✓\* | ✓ |
| HyperEVM Testnet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Immutable zkEVM | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Immutable zkEVM Testnet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Incentiv | ✓ | ✓ | ✓ | ✗ | ✗ |
| Injective | ✓ | ✓ | ✓ | ✗ | ✓ |
| Ink | ✓ | ✓ | ✓ | ✓\* | ✓ |
| Ink Sepolia | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| IOTA EVM | ✓ | ✓ | ✓ | ✓ | ✗ |
| Kaia | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Katana | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Linea | ✓ | ✓ | ✓ | ✓\* | ✓ |
| Linea Sepolia | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Lisk | ✓ | ✓ | ✓ | ✓ | ✓ |
| Lisk Sepolia | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Litecoin | ✓ | ✓ | ✗ | ✗ | ✗ |
| LitVM Liteforge Testnet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Lyra | ✓ | ✓ | ✓ | ✓\* | ✓ |
| Lyra Testnet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Mantle | ✓ | ✓ | ✓ | ✗ | ✗ |
| MegaETH | ✓ | ✓ | ✓ | ✓\* | ✓ |
| MegaETH Testnet | ✓ | ✓ | ✓ | ✗ | ✓ |
| Metal | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Metal Testnet | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Mezo | ✓ | ✓ | ✓ | ✓ | ✓ |
| Mezo Testnet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Moca | ✓ | ✓ | ✓ | ✓ | ✗ |
| Moca Testnet | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Mode | ✓ | ✓ | ✓ | ✓ | ✓ |
| Mode Testnet | ✓ | ✓ | ✓ | ✓ | ✓ |
| Monad | ✓ | ✓ | ✓ | ✓\* | ✓ |
| Monad Testnet | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Morph | ✓ | ✓ | ✓ | ✗ | ✓ |
| Neura Testnet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Oasis Consensus | ✓ | ✓ | ✗ | ✗ | ✓ |
| Oasis Consensus Testnet | ✓ | ✓ | ✗ | ✗ | ✓ |
| Optimism | ✓ | ✓ | ✓ | ✓ | ✓ |
| Optimism Sepolia | ✓ | ✓ | ✓ | ✓ | ✓ |
| Orderly | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Orderly Sepolia | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Pharos | ✓ | ✓ | ✓ | ✓ | ✓ |
| Pharos Atlantic Testnet | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Plasma | ✓ | ✓ | ✓ | ✓\* | ✓ |
| Plasma Testnet | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Plume | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Polygon | ✓ | ✓\* | ✓ | ✓ | ✓ |
| Polygon Amoy Testnet | ✓ | ✓ | ✓ | ✓ | ✗ |
| Polynomial | ✓ | ✓ | ✓ | ✓ | ✗ |
| Proof of Play Apex | ✓ | ✓ | ✓ | ✗ | ✓ |
| Proof of Play Barret | ✓ | ✓ | ✓ | ✓ | ✗ |
| Proof of Play Boss | ✓ | ✓ | ✓ | ✓ | ✗ |
| Proof of Play Cid | ✓ | ✓ | ✓ | ✓ | ✗ |
| Proof of Play Cloud | ✓ | ✓ | ✓ | ✓ | ✗ |
| Public Goods Network | ✓ | ✓ | ✓ | ✓ | ✓ |
| Race | ✓ | ✓ | ✓ | ✓ | ✗ |
| Redstone | ✓ | ✓ | ✓ | ✓ | ✓ |
| Reya | ✓ | ✓ | ✓ | ✗ | ✓ |
| Rise | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Rise Sepolia | ✓ | ✓ | ✓ | ✗ | ✗ |
| Robinhood Chain | ✓ | ✓ | ✓ | ✓ | ✓ |
| Robinhood Chain Testnet | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Ronin | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Rootstock | ✓ | ✓ | ✓ | ✗ | ✓ |
| Scroll | ✓ | ✓ | ✓ | ✓ | ✓ |
| Sei | ✓ | ✓ | ✓ | ✗ | ✓ |
| Settlus | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Shape | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Shape Sepolia | ✓ | ✓ | ✓ | ✓ | ✓ |
| Soneium | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Soneium Minato | ✓ | ✓ | ✓ | ✗ | ✗ |
| Sonic | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Sophon | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Stable | ✓ | ✓ | ✓ | ✗ | ✓ |
| Superseed | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| Superseed Sepolia | ✓ | ✓ | ✓ | ✓ | ✓ |
| Swan | ✓ | ✓ | ✓ | ✓ | ✗ |
| Taiko Hoodi Testnet | ✓ | ✓ | ✓ | ✗ | ✗ |
| Tempo | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Tempo Moderato Testnet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| TRON | ✓ | ✓ | ✓ | ✗ | ✓ |
| Unichain | ✓ | ✓ | ✓ | ✓ | ✓ |
| Unichain Testnet | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Viction | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| World Chain | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
| X Layer | ✓ | ✓ | ✓ | ✗ | ✓ |
| Xai | ✓ | ✓ | ✓ | ✓ | ✓ |
| Xai Testnet | ✓ | ✓ | ✓ | ✓ | ✓ |
| XPLA | ✓\* | ✓\* | ✓ | ✗ | ✓ |
| Zenith Testnet EVM | ✓ | ✓ | ✓ | ✗ | ✗ |
| zkSync Era | ✓ | ✓ | ✓ | ✓ | ✓ |
| Zora | ✓ | ✓\* | ✓ | ✓ | ✓ |
| Zora Sepolia | ✓\* | ✓\* | ✓ | ✓\* | ✓ |
Arweave's transaction datasets include bundled/L2 data (`raw_transactions` and `raw_unbundled_transactions`).
### Non-EVM chains
#### Beacon
| Dataset | Description |
| - | - |
| Attestations | Attestations (votes) from validators for the block. |
| Attester Slashing | Metadata for attester slashing. |
| Blocks | Metadata for each block on the chain including hashes, deposit count, and gas used. |
| BLS Signature to Execution Address Changes | BLS Signature to Execution Address Changes. |
| Deposits | Metadata for deposits. |
| Proposer Slashing | Metadata for proposer slashing. |
| Voluntary Exits | Metadata for voluntary exits. |
| Withdrawls | Metadata for withdrawls. |
#### Fogo
| Dataset | Description |
| - | - |
| Transactions with Instructions | Enriched transaction data including instructions, accounts, balance changes, and metadata for the block. |
| Rewards | Records of rewards distributed to validators for securing and validating the network. |
| Blocks | Metadata for each block on the chain including hashes, transaction count, slot and leader rewards. |
#### IOTA
| Dataset | Description |
| - | - |
| Checkpoints | A checkpoint is a periodic, finalized snapshot of the blockchain's state in the Movement VM, batching transactions to ensure consistency and scalability across the network. |
| Epochs | An epoch is a defined time period in the Movement VM during which a fixed set of validators processes transactions and manages governance, with transitions enabling validator rotation and network updates. |
| Events | Events in the Movement VM are structured data emissions from smart contracts, recorded on the blockchain to log significant actions or state changes for external monitoring and interaction. |
| Move Calls | Move calls are a function invocation within a Move smart contract, executed by the Movement VM to perform specific operations or state transitions on the blockchain. |
| Transactions | A transaction in the Movement VM is a signed instruction executed by the Move smart contract to modify the blockchain's state, such as transferring assets or invoking contract functions. |
#### Movement
| Dataset | Description |
| - | - |
| Account Transactions | All raw onchain transactions involving account-level actions (e.g., transaction version, account address). |
| Block Metadata Transactions | Metadata about blocks and block-level transactions (e.g., block height, epoch, version). |
| Fungible Asset Balances | Real-time balances of fungible tokens across accounts. |
| Current Token Data | Latest metadata for tokens - includes name, description, supply, etc. |
| Current Token Ownerships | Snapshot of token ownership across the chain. |
| Events | All emitted contract event logs - useful for indexing arbitrary contract behavior. |
| Fungible Asset Activities | Track activity for fungible tokens - owner address, amount, and type. |
| Fungible Asset Balances | Historical balance tracking for fungible assets (not just the current state). |
| Fungible Asset Metadata | Static metadata for fungible tokens - like decimals, symbol, and name. |
| Signatures | Cryptographic signature data from transactions, useful for validating sender authenticity. |
| Token Activities | Detailed logs of token movements and interactions across tokens and NFTs. |
#### NEAR
NEAR datasets are no longer available through Mirror. Use [Turbo pipelines](/turbo-pipelines/sources/near) for NEAR data.
#### Solana
Solana datasets are no longer available through Mirror. Use [Turbo pipelines](/turbo-pipelines/sources/solana) for Solana data.
#### Starknet
| Dataset | Description |
| - | - |
| Blocks | Metadata for each block on the chain including hashes, transaction count, difficulty, and gas used. |
| Events | Consists of raw event data from the blockchain, documenting various on-chain activities and triggers. |
| Messages | Messaging data from the Starknet blockchain, used for L2 & L1 communication. |
| Transactions | Transaction data including input, value, from and to address, and metadata for the block, gas, and receipts. |
#### Stellar
Stellar datasets are no longer available through Mirror. Use [Turbo pipelines](/turbo-pipelines/sources/stellar) for Stellar data.
#### Sui
| Dataset | Description |
| - | - |
| Checkpoints | Contains raw data of blockchain checkpoints capturing the state of the ledger at specific intervals. |
| Epochs | Includes raw data detailing the various epochs in the blockchain, which mark significant periods or phases in the network's operation |
| Events | Consists of raw event data from the blockchain, documenting various on-chain activities and triggers |
| Packages | Contains raw data about the deployed smart contract packages on the blockchain |
| Transactions | Transaction data including effects, events, senders, recipients, balance and object changes, and other metadata. |
### Curated Datasets
Beyond onchain datasets, the Goldsky team continuosly curates and publishes derived datasets that serve a specific audience or use case. Here's the list:
#### Token Transfers
You can expect every EVM chain to have the following datasets available:
| Dataset | Description |
| - | - |
| ERC\_20 | Every transfer event for all fungible tokens. |
| ERC\_721 | Every transfer event for all non-fungible tokens. |
| ERC\_1155 | Every transfer event for all ERC-1155 tokens. |
#### Polymarket datasets
| Dataset | Description |
| - | - |
| Order Filled | This event is emitted when a single Polymarket order is partially or completely filled. For example: a 50c YES buy for 100 YES matched against a 50c YES sell for 100 YES will emit 2 Orderi Filled events, from the perspective of the YES buy and of the YES sell. This is useful for granular tracking of trading activity and history. |
| Orders Matched | This event is emitted when a Polymarket taker order is matched against a set of Polymarket maker(limit) orders. For example: a 50c YES buy for 200 YES matched against 2 50c YES sells for 100 YES each will emit a single Orders Matched event. Orders Matched gives a more high level view of trading activity as it only tracks taker activity. |
| User Balances | This event keeps track of all user outcome token positions. |
| User Positions | Keeps track of outcome token positions along with pnl specific data including average price and realized pnl. |
Additional chains, including roll-ups, can be indexed on demand. Contact us at [sales@goldsky.com](mailto:sales@goldsky.com) to learn more.
## Missing a chain?
If you need a network we don't support yet, [reach out](/getting-support): chain onboarding is often fast, and partner chains can sponsor coverage for their ecosystem.
# Swan Chain
Source: https://docs.goldsky.com/chains/swan
Swan Chain support on Goldsky: Turbo pipelines on Swan mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Taiko
Source: https://docs.goldsky.com/chains/taiko
Taiko support on Goldsky: Turbo pipelines on Taiko Hoodi Testnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# The Binary Holdings
Source: https://docs.goldsky.com/chains/tbh
The Binary Holdings support on Goldsky: current availability for Binary Testnet, CLI setup steps, and how to reach the team about enabling The Binary Holdings.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Telos EVM
Source: https://docs.goldsky.com/chains/telos-evm
Telos EVM support on Goldsky: Subgraphs on Telos mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Tempo
Source: https://docs.goldsky.com/chains/tempo
Tempo support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Tempo Mainnet and Tempo Moderato Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Tenet
Source: https://docs.goldsky.com/chains/tenet
Tenet support on Goldsky: current availability for Tenet, how to get started with the CLI, and how to reach the team about enabling Tenet.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# ThunderCore
Source: https://docs.goldsky.com/chains/thundercore
ThunderCore support on Goldsky: Subgraphs on ThunderCore mainnet and ThunderCore Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Treasure
Source: https://docs.goldsky.com/chains/treasure
Treasure support on Goldsky: current availability for Treasure Mainnet, how to get started with the CLI, and how to reach the team about enabling Treasure.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# TRON
Source: https://docs.goldsky.com/chains/tron
TRON support on Goldsky: Turbo pipelines on TRON mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Unichain
Source: https://docs.goldsky.com/chains/unichain
Unichain support on Goldsky: Turbo pipelines, Edge RPC, Compose, and Subgraphs on Unichain mainnet and Unichain Testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Vana
Source: https://docs.goldsky.com/chains/vana
Vana support on Goldsky: Subgraphs on Vana mainnet and Vana Moksha, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Viction
Source: https://docs.goldsky.com/chains/viction
Viction support on Goldsky: Turbo pipelines on Viction mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Volmex Finance
Source: https://docs.goldsky.com/chains/volmex
Volmex Finance support on Goldsky: current availability, CLI setup steps, and how to reach the team about enabling Volmex Finance.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# World Chain
Source: https://docs.goldsky.com/chains/worldchain
World Chain support on Goldsky: Turbo pipelines on World Chain mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# XDC Network
Source: https://docs.goldsky.com/chains/xdc
XDC Network support on Goldsky: Subgraphs on XDC mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# X Layer
Source: https://docs.goldsky.com/chains/xlayer
X Layer support on Goldsky: Turbo pipelines and Subgraphs on X Layer mainnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# XPLA
Source: https://docs.goldsky.com/chains/xpla
XPLA support on Goldsky: Turbo pipelines on XPLA mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# XRADERS
Source: https://docs.goldsky.com/chains/xr
XRADERS support on Goldsky: current availability for Xr Sepolia, how to get started with the CLI, and how to reach the team about enabling XRADERS.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# XRPL EVM Sidechain
Source: https://docs.goldsky.com/chains/xrpl-evm
XRPL EVM Sidechain support on Goldsky: Subgraphs on XRPL EVM mainnet and XRPL EVM Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Xterio
Source: https://docs.goldsky.com/chains/xterio
Xterio support on Goldsky: current availability for Xterio, how to get started with the CLI, and how to reach the team about enabling Xterio.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Zenith
Source: https://docs.goldsky.com/chains/zenith
Zenith support on Goldsky: Turbo pipelines on Zenith Testnet EVM, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Zero
Source: https://docs.goldsky.com/chains/zero
Zero support on Goldsky: current availability for Zero Mainnet and Zero Sepolia, how to get started with the CLI, and how to reach the team about enabling Zero.
## Overview
### Partnership
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Zircuit
Source: https://docs.goldsky.com/chains/zircuit
Zircuit support on Goldsky: Subgraphs on Zircuit mainnet and Zircuit Garfield Testnet, with CLI setup steps to get started.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# zkLink Nova
Source: https://docs.goldsky.com/chains/zklink-nova
zkLink Nova support on Goldsky: Subgraphs on zkLink Nova mainnet, with CLI setup steps to get started and where to get support.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# zkSync Era
Source: https://docs.goldsky.com/chains/zksync-era
zkSync Era support on Goldsky: Turbo pipelines, Edge RPC, and Compose on zkSync Era mainnet, plus Subgraphs on mainnet and testnet, with CLI setup steps.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Zora
Source: https://docs.goldsky.com/chains/zora
Zora support on Goldsky: Turbo pipelines and Subgraphs on Zora mainnet and Zora Sepolia, plus Edge RPC and Compose on mainnet, with CLI setup steps.
## Overview
## Getting started
To use Goldsky, you'll need to create an account, install the CLI, and log in. If you want to use Turbo or Compose, you'll also need to install their respective CLI extensions.
1. Install the Goldsky CLI:
**For macOS/Linux:**
```shell theme={"dark"}
curl https://goldsky.com | sh
```
**For Windows:**
```shell theme={"dark"}
npm install -g @goldskycom/cli
```
Windows users need to have Node.js and npm installed first. Download from [nodejs.org](https://nodejs.org) if not already installed.
2. Log into your Project by running:
```shell theme={"dark"}
goldsky login
```
This opens your browser to sign in (Google, GitHub, SSO, or email). Once you authenticate, the CLI is logged in automatically — there's no API key to copy or paste.
On a headless or remote machine (or in CI), create an API key on your [Project Settings](https://app.goldsky.com/dashboard/settings) page and pass it directly with `goldsky login --token `. Use `goldsky login --no-browser` to print the login URL instead of opening a browser.
3. Now that you are logged in, run `goldsky` to get started:
```shell theme={"dark"}
goldsky
```
If you already have the Goldsky CLI installed, install the Turbo extension by running:
```bash theme={"dark"}
goldsky turbo
```
This will automatically install the Turbo extension. Verify the installation:
```bash theme={"dark"}
goldsky turbo list
```
Make sure to update the CLI to the latest version before running Turbo commands: `curl https://goldsky.com | sh`
For a complete reference of all Turbo CLI commands, see the [CLI Reference](/turbo-pipelines/cli-reference) guide.
If you already have the Goldsky CLI installed, install the Compose extension by running:
```bash theme={"dark"}
goldsky compose install
```
To update to the latest version:
```bash theme={"dark"}
goldsky compose update
```
For more details, see the [Compose quickstart](/compose/quick-start) guide.
## Subgraphs
## Turbo
## Edge RPC
## Compose
## Getting support
Can't find what you're looking for? Reach out to us at [support@goldsky.com](mailto:support@goldsky.com) for help.
# Changelog
Source: https://docs.goldsky.com/changelog
Product updates and release notes from Goldsky.
# Compose app manifest configuration reference
Source: https://docs.goldsky.com/compose/app-configuration
Configure the Compose app manifest YAML with app properties, tasks, triggers, secrets, environment variables, and stable or preview release channels.
The Compose App manifest is a YAML file that defines your app's configuration. This is where you configure a list of tasks and other app-level concerns.
Each task can be individually configured for things like retry behavior and HTTP trigger behavior, cron schedules and more.
## App properties
| Property | Type | Required | Description |
| - | - | - | - |
| `name` | string | Yes | Unique app identifier used for API calls. Must start and end with a letter or number, and contain only letters, numbers, underscores, and hyphens. |
| `api_version` | string | For deploy | Pins your app to a Compose runtime version. Required by `goldsky compose deploy`; optional for local dev. Use `"stable"` if unsure (see [Release channels](#release-channels) below). |
| `secrets` | array(string) | No | Names of secrets you've set for this app (see [Secrets](./secrets)) |
| `env` | [ENV](#env-variables) | No | Environment-specific variables |
| `tasks` | [Tasks\[\]](#task-configuration) | Yes | List of tasks in your app (must contain at least one task) |
### Release channels
`api_version` pins your app to a Compose runtime version. You can use one of the release channels, or pin to a specific version:
* `"stable"`: the current stable runtime. This is the recommended value for production apps.
* `"preview"`: the latest pre-release runtime. Use this if you want early access to features that haven't made it into `stable` yet. Expect more frequent changes.
* A specific semver version (e.g. `"0.3.0"`): pin to an exact runtime version. Useful when you want full control over when your app picks up runtime changes. Do not include a `v` prefix. See the [changelog](https://goldsky.com/changelog) for available versions.
If your manifest's `api_version` is older than the CLI, `goldsky compose deploy` will warn you and prompt before continuing. Pass `-f` to skip the prompt.
## Basic example
```yaml theme={"dark"}
name: "my-app"
api_version: "stable"
secrets:
- MY_SECRET
env:
local:
MY_VAR: "foo"
cloud:
MY_VAR: "bar"
tasks:
- name: "price_fetcher"
path: "./tasks/fetch_price.ts"
triggers:
- type: "cron"
expression: "* * * * *" # Run every minute
- type: "http"
authentication: "auth_token"
retry_config:
max_attempts: 3
initial_interval_ms: 1000
backoff_factor: 2
- name: "data_processor"
path: "./tasks/process_data.ts"
```
## ENV variables
You can set env variables in your manifest, which are injected into your task's [env context property](./context/env). Env configuration is namespaced by environment, and only the values for the current environment are injected. Currently there are two environments: `local`, used when running your compose app locally, and `cloud`, used when your app is running after `goldsky compose deploy` (see the [deploy guide](./deploy-monitor)).
Values must be strings. For anything sensitive (API keys, private keys), use [secrets](./secrets) instead.
### Example
```yaml theme={"dark"}
name: "my-app"
env:
local:
MY_VAR: "foo"
ANOTHER_VAR: "bar"
cloud:
MY_VAR: "foo-prod"
ANOTHER_VAR: "bar-prod"
```
## Task configuration
Each task in the `tasks` array defines an executable unit of work and references a typescript file; see [Task Authoring](./tasks) for
more details. Tasks can be triggered by HTTP requests from your app,
blockchain events, cron schedules, etc. See more about triggers below. Tasks can also trigger other tasks via the [callTask context function](./context/call-task)
within the task code.
```yaml theme={"dark"}
name: "my-app"
api_version: "stable"
tasks:
- name: "unique_task_name" # Required: Unique identifier
path: "./tasks/my_task.ts" # Required: Path to task file
triggers:
- type: "http"
authentication: "auth_token"
- type: "cron"
expression: "*/5 * * * *" # Every 5 minutes
retry_config: # Optional: Task-level retry settings
max_attempts: 5
initial_interval_ms: 2000
backoff_factor: 1.5
```
### Name validation
**App names** must start and end with a letter or number, and contain only letters, numbers, underscores, and hyphens (e.g. `my-app-1`). The pattern is `/^[a-zA-Z0-9]([a-zA-Z0-9_\-]*[a-zA-Z0-9])?$/`.
**Task names** must start with a letter or number, and contain only letters, numbers, underscores, hyphens, and dots (e.g. `fetch_prices`, `oracle.update`). The pattern is `/^[a-zA-Z0-9][a-zA-Z0-9_.\-]*$/`. A leading underscore is no longer allowed.
Names that canonicalize the same (lowercased, with runs of `-`/`_` collapsed to `-`) cannot coexist in a project. `my-app`, `My_App`, and `my__app` are treated as the same name, so the second deploy gets a conflict error.
### Task properties
| Property | Type | Required | Description |
| - | - | - | - |
| `name` | string | Yes | Unique task identifier used for API calls |
| `path` | string | Yes | File path to the task module |
| `triggers` | array(object) | No | List of triggers that will run the task. Each trigger type can only appear once per task. |
| `retry_config` | object | No | Task-level retry behavior |
### Triggers
Triggers run your Compose tasks: HTTP calls, onchain events, or cron jobs. For more information, see [Triggers](./task-triggers).
#### Example
```yaml theme={"dark"}
triggers:
- type: "cron"
expression: "* * * * *" # Run every minute (standard cron expression)
- type: "http"
authentication: "auth_token"
```
Onchain event triggers can also be processed in parallel, with an optional confirmation delay for reorg safety:
```yaml theme={"dark"}
triggers:
- type: "onchain_event"
network: "ethereum"
contract: "0xb74de3F91e04d0920ff26Ac28956272E8d67404D"
parallel_processing: true
max_concurrency: 50 # defaults to 10
confirmations: 10 # defaults to 0 (fire at chain head)
```
See [Parallel processing](./task-triggers#parallel-processing) and [Confirmations](./task-triggers#confirmations) for the full behavior of these fields.
If you provide no triggers in your manifest then tasks can only be executed by other tasks.
### Retry configuration
```yaml theme={"dark"}
retry_config:
max_attempts: 3 # Maximum number of retry attempts
initial_interval_ms: 1000 # Initial delay before first retry
backoff_factor: 2 # Exponential backoff multiplier
```
When specifying `retry_config`, all three fields (`max_attempts`, `initial_interval_ms`, `backoff_factor`) are required. You cannot provide only some of them.
**How retries work:**
* If a task fails, Compose waits `initial_interval_ms` before retrying
* Each subsequent retry interval is multiplied by `backoff_factor`
* Example with above config: 1000ms → 2000ms → 4000ms
* After `max_attempts` failures, the task is marked as permanently failed
* When `retry_config` is omitted, tasks default to `max_attempts: 3`, `initial_interval_ms: 1000`, and `backoff_factor: 2`.
## Manifest examples
### Multi-chain oracle
```yaml theme={"dark"}
name: "multi-chain-oracle"
api_version: "stable"
tasks:
- name: "fetch_prices"
path: "./tasks/fetch_crypto_prices.ts"
retry_config:
max_attempts: 5
initial_interval_ms: 2000
backoff_factor: 1.5
- name: "update_ethereum_oracle"
path: "./tasks/update_oracle.ts"
triggers:
- type: "cron"
expression: "* * * * *" # Every minute
retry_config:
max_attempts: 3
initial_interval_ms: 5000
backoff_factor: 2
- name: "update_polygon_oracle"
path: "./tasks/update_oracle.ts"
triggers:
- type: "cron"
expression: "* * * * *" # Every minute
```
### Event processing pipeline
```yaml theme={"dark"}
name: "event-processor"
api_version: "stable"
tasks:
- name: "event_processing"
path: "./tasks/process_events.ts"
triggers:
- type: "onchain_event"
network: "base"
contract: "0xb74de3F91e04d0920ff26Ac28956272E8d67404D"
events:
- "Transfer(address,address,uint256)"
retry_config:
max_attempts: 10
initial_interval_ms: 1000
backoff_factor: 1.2
```
### High-volume event processing
Onchain events processed concurrently, each held until its block is 5 blocks deep.
```yaml theme={"dark"}
name: "settlement-processor"
api_version: "stable"
tasks:
- name: "settle_trade"
path: "./tasks/settle_trade.ts"
triggers:
- type: "onchain_event"
network: "ethereum"
contract: "0xb74de3F91e04d0920ff26Ac28956272E8d67404D"
events:
- "TradeExecuted(address,uint256)"
parallel_processing: true
max_concurrency: 25
confirmations: 5
retry_config:
max_attempts: 5
initial_interval_ms: 1000
backoff_factor: 2
```
# App Lifecycle
Source: https://docs.goldsky.com/compose/app-lifecycle
Inspect, pause, resume, delete, and tail logs from a deployed Compose app using the Goldsky CLI.
Once your Compose app is deployed, a set of CLI commands let you inspect, pause, resume, delete, tail logs, and review its deploy history, task runs, collections, and deployed source. The per-app commands (`status`, `pause`, `resume`, `logs`, `delete`, `history`, `runs`, `collections`, `source`, `download`) accept either `-n, --name ` to target by name, or `-m, --manifest ` (default `compose.yaml`) to read the name from your manifest. `list` is project-wide and accepts neither.
Every command also accepts `--json` so you can pipe output into scripts or agents.
## Check status
```bash theme={"dark"}
goldsky compose status
```
Shows the app's name, current runtime status (e.g. `RUNNING`, `PAUSED`, `STARTING`, `ERROR`), and timestamps for when it was created and last updated.
```bash theme={"dark"}
# status for a specific app, as JSON
goldsky compose status -n my-app --json
```
## List apps
```bash theme={"dark"}
goldsky compose list
```
Prints a table of every Compose app in your project.
```bash theme={"dark"}
# list as JSON for scripting
goldsky compose list --json
```
## Pause and resume
```bash theme={"dark"}
goldsky compose pause
goldsky compose resume
```
While paused, cron triggers stop firing and HTTP triggers return an error. State is preserved: `resume` picks up where the app left off. This is useful for:
* Triaging a misbehaving app without deleting it
* Holding execution while you roll out a dependency change
* Temporarily stopping a cron while you investigate its effects
## View logs
```bash theme={"dark"}
goldsky compose logs
```
By default `logs` prints the most recent 100 lines. You can tail live, filter by level or text, and bound the output by time or line count.
```bash theme={"dark"}
# tail live
goldsky compose logs -f
# live, errors and warnings only
goldsky compose logs -f --level error,warn
# last hour
goldsky compose logs --since 1h
# search for a substring across the last 500 lines
goldsky compose logs --tail 500 --search "timeout"
# tail live for 5 minutes, then exit
goldsky compose logs -f --timeout 5m
```
Options cheat-sheet:
| Flag | Description |
| - | - |
| `-f, --follow` | Stream logs live |
| `--tail ` | Number of lines to fetch (default: `100`) |
| `--level ` | Comma-separated levels (e.g. `error,warn`) |
| `--search ` | Filter lines by text |
| `--since ` | Logs since a relative time (e.g. `1h`, `30m`, `7d`) |
| `--max-lines ` | Exit after N lines |
| `--timeout ` | Exit after a duration (e.g. `5m`) |
| `--json` | Emit newline-delimited JSON |
## Inspect deploy history and task runs
Use `goldsky compose history` to see what was deployed and when:
```bash theme={"dark"}
goldsky compose history -n my-app
# include failed deploys in the list
goldsky compose history -n my-app --include-failures
```
When a task run fails, narrow the `runs` list with `--task`, `--status`, or `--since` to find it, then fetch the full run detail by id:
```bash theme={"dark"}
# recent runs of a specific task
goldsky compose runs -n my-app --task price_fetcher --limit 10
# failing runs in the last hour
goldsky compose runs -n my-app --status error --since 1h
# full detail for one run
goldsky compose runs -n my-app
```
Pipe `--json` output into `jq` to drive scripts or alerts:
```bash theme={"dark"}
goldsky compose runs -n my-app --status error --json | jq '.runs[].runId'
```
For all flags, see the [CLI reference](./cli-reference#inspecting-a-deployed-app).
## Query collections
List every collection in your app's hosted database, then query one with a JSON filter:
```bash theme={"dark"}
goldsky compose collections list -n my-app
goldsky compose collections query prices -n my-app --filter '{"symbol": "BTC"}' --limit 10
```
For all flags, see the [CLI reference](./cli-reference#inspecting-a-deployed-app).
## View and download deployed source
Print the deployed source for your app, or for a single task:
```bash theme={"dark"}
# list the deployed files
goldsky compose source -n my-app
# print one task's source
goldsky compose source -n my-app bitcoin_oracle
```
Download a runnable copy of the whole app as a zip:
```bash theme={"dark"}
goldsky compose download -n my-app
```
The same source is available in the dashboard's Code tab, with a Download app button that produces the same archive. See [Deploying and monitoring](./deploy-monitor#viewing-and-downloading-deployed-source) for details.
For all flags, see the [CLI reference](./cli-reference#inspecting-a-deployed-app).
## Delete an app
```bash theme={"dark"}
goldsky compose delete
```
By default `delete` is interactive: it asks you to type the app name to confirm, and separately asks whether you also want to delete the app's hosted Postgres database.
```bash theme={"dark"}
# non-interactive (CI-safe) — skip all prompts
goldsky compose delete -f
# non-interactive, also drop the Postgres database
goldsky compose delete -f --delete-database
```
See [Deploying and monitoring](./deploy-monitor#deleting-a-compose-app) for how database deletion interacts with active pipelines.
Deleting an app is permanent. Deleting its database is permanent too, and cannot be undone. Back up anything you care about first.
## Next Steps
Learn about deploying your app to the cloud.
View the full CLI command reference.
# Compose CLI Reference
Source: https://docs.goldsky.com/compose/cli-reference
Reference for the Compose CLI manifest schema, commands, and configuration options.
## Manifest
The Compose App's manifest is a YAML file with the following schema. The manifest holds all the relevant information about the Compose App and its tasks.
All compose commands will reference your manifest and pick up the configuration there. See full manifest configuration docs [here](./app-configuration).
### Example
```yaml theme={"dark"}
name: "my_app"
api_version: "stable"
secrets:
- MY_SECRET
env:
local:
MY_VAR: "foo"
cloud:
MY_VAR: "bar"
tasks:
- name: "price_fetcher"
path: "./tasks/fetch_price.ts"
triggers:
- type: "cron"
expression: "* * * * *" # Run every minute
- type: "http"
authentication: "auth_token"
retry_config:
max_attempts: 3
initial_interval_ms: 1000
backoff_factor: 2
- name: "data_processor"
path: "./tasks/process_data.ts"
```
## App targeting
Most commands that operate on a deployed app accept either `-n, --name ` to target by name directly, or `-m, --manifest ` (default `compose.yaml`) to read the name from a manifest. If neither is provided and no `compose.yaml` is present, the command errors. A few commands (`deploy`, `wallet create`, `wallet list`) only support `-m, --manifest`.
## Scripting and automation
Most Compose commands can run non-interactively, which lets you drive deploys and inspections from CI, scripts, and agents.
### Authentication
Every command that talks to the platform needs an auth token. The token is resolved in this order: the `-t, --token ` flag, then the `GOLDSKY_API_TOKEN` environment variable, then the token written by `goldsky login`. If none is present, the command errors:
```text theme={"dark"}
Please run goldsky login, set GOLDSKY_API_TOKEN, or pass --token to the command.
```
### JSON output
Pass `--json` to any command that talks to the platform for machine-readable output: `deploy`, `callTask`, `status`, `list`, `history`, `runs`, `collections list`, `collections query`, `source`, `download`, `pause`, `resume`, `delete`, `logs`, `secret list`, `wallet create`, `wallet list`, `writeContract`, and `deployContract`. Note that `secret set` and `secret delete` do not accept it.
In `--json` mode stdout carries only the result document; progress bars and other decoration are suppressed. Failures go to stderr as a JSON envelope and the command exits with code 1:
```json theme={"dark"}
{ "error": true, "code": "VALIDATION_FAILED", "message": "..." }
```
Error codes include `VALIDATION_FAILED`, `SECRET_MISSING`, `DEPLOY_FAILED`, `ALREADY_DEPLOYED`, `NOT_FOUND`, `WRITE_CONTRACT_FAILED`, `USAGE`, and `UNKNOWN`. `USAGE` is returned for an unknown command or for `-n` on `deploy`.
### Non-interactive behavior
In a non-TTY (CI, scripts, agents), interactive prompts are skipped or error out:
* `goldsky compose init ` accepts the project name as an argument and skips the prompt. Without a name it errors in non-interactive mode.
* `goldsky compose deploy` aborts on a major `api_version` mismatch unless you pass `--force`. A minor mismatch defaults to continuing.
* `goldsky compose clean` and `goldsky compose delete` require `-f, --force` in non-interactive mode.
### Example: scripted deploy
```bash theme={"dark"}
export GOLDSKY_API_TOKEN=gs_tok_...
goldsky compose deploy --json | jq -r .dashboard_url
```
## Commands
### init \[name]
Prompts you for a project name and scaffolds a folder of that name containing a working Compose app (a Bitcoin price oracle example you can run right away). Pass the name as an argument to skip the prompt; the name is required in non-interactive mode.
```bash theme={"dark"}
goldsky compose init my-app
```
### start
Starts your app locally. Preserves execution state from previous runs, useful for testing retry behavior and other production scenarios. By default the server binds port 4000; if that port is taken it walks up to 4009 and uses the first free port.
```bash theme={"dark"}
goldsky compose start
```
Options:
* `-m, --manifest ` Path to manifest file (default: `compose.yaml`)
* `--fork-chains` Fork all chains referenced in contract interactions locally for testing (see [forking](./environments#forking-for-local-compose-development))
* `--impersonate ` Impersonate wallet addresses on the local fork (e.g. `"wallet1=0xAddr1,wallet2=0xAddr2"`). Requires `--fork-chains`. See [Impersonated wallets](./context/evm/wallets#impersonated-wallets)
* `-p, --port ` Bind exactly this port; fails fast if it is already in use (no walking)
### deploy
Deploys the app to the cloud. On success it prints the dashboard URL, which is also available as `dashboard_url` when you pass `--json`. See [monitoring](./deploy-monitor) for more info. In a non-TTY, a major `api_version` mismatch aborts the deploy unless you pass `--force`; see [Scripting and automation](#scripting-and-automation).
```bash theme={"dark"}
goldsky compose deploy
```
Options:
* `-m, --manifest ` Path to manifest file (default: `compose.yaml`)
* `-t, --token ` Authentication token for deployment
* `-f, --force` Skip version compatibility prompts
* `--sync-env` Upload secrets from your local `.env` to the cloud before deploying, in one step. See [Secrets](./secrets).
* `--json` Emit the deploy result as JSON (includes `dashboard_url`)
Your manifest must include an `api_version` field to deploy. All secrets referenced in the manifest must be set before deploying (see [Secrets](./secrets)).
`deploy` takes the app name from the manifest, so it has no `-n, --name` flag. Passing one exits with code 1 and a one-line error instead of the full help text. An unknown command, such as `goldsky compose app`, also exits with code 1 and prints `unknown command 'app'`.
### callTask
Call a task by name with a JSON payload. By default the task runs on your deployed app; pass `--env local` (or `-p, --port`) to hit a locally running server instead.
```bash theme={"dark"}
# call a task on the deployed app (default)
goldsky compose callTask my_task '{"foo": "bar"}'
# call a task on a locally running app
goldsky compose callTask my_task '{"foo": "bar"}' --env local
```
Options:
* `--env ` Where to run the task (default: `cloud`). Passing `--port` implies local
* `-p, --port ` Local port to call. Implies `--env local`; an error if combined with an explicit `--env cloud`
* `-n, --name ` App name (alternative to `-m`)
* `-m, --manifest ` Path to manifest file (default: `compose.yaml`)
* `-t, --token ` Authentication token
* `--json` Emit the response as JSON
When calling a local server, the port is resolved in this order: the `--port` flag, then the `.compose/.port` file, then 4000.
Both the task name and the JSON payload are required. The payload must be valid JSON: `{foo: "bar"}` is invalid, use `{"foo": "bar"}` (or `'{}'` if the task takes no input) instead.
### codegen
Parse ABIs in the `src/contracts/` folder and generate TypeScript classes for them.
See [contracts](./context/evm/contracts) for more details.
```bash theme={"dark"}
goldsky compose codegen
```
### deployContract
Compile a Solidity contract and deploy it to a chain, with gas sponsored from your app's wallet. The contract is compiled locally (no `forge` or `solc` install required) and deployed through a CREATE2 deterministic deployment proxy, so deploying the same contract from the same app produces the same address on every chain. The deployed address is printed before the transaction is sent, followed by `Submitting UserOp on ...` while the transaction is in flight. The block it was deployed in is printed on success, and the ABI is written to `src/contracts/.json` so you can run [`codegen`](#codegen) against it. With `--json`, progress lines are not printed.
Imports are resolved from `node_modules/`, so OpenZeppelin and other published contracts work after a normal `npm install`. The wallet this deploys from is the same on-chain identity as `evm.wallet({ name })` in your task code for a given app and wallet name. `deployContract` and `writeContract` both work before your app's first deploy, so you can deploy a contract and use its address before anything is running.
```bash theme={"dark"}
goldsky compose deployContract src/contracts/MyToken.sol \
--chain-id 84532 \
--constructor-args 0xRecipient 1000000
```
Options:
* `--chain-id ` Chain to deploy to, e.g. `8453` for Base or `84532` for Base Sepolia (required)
* `--constructor-args ` Constructor arguments, space-separated (one value per argument)
* `--verify` Verify the contract's source on the chain's block explorer after deploying. Opt-in because publishing source is irreversible and verification adds roughly 30 to 90 seconds
* `--wallet ` Named wallet to deploy from (default: `default`). Shares identity with `evm.wallet({ name })` in task code
* `--force` Deploy even if `msg.sender` usage is detected in the constructor (see note below)
* `-m, --manifest ` Path to manifest file (default: `compose.yaml`)
* `-t, --token ` Authentication token
* `--api-server ` Override the API server URL
* `--json` Emit the deploy result as JSON
Because deployment routes through the CREATE2 proxy, `msg.sender` inside your constructor is the proxy address, not your wallet. If your constructor uses `msg.sender` (for example `Ownable(msg.sender)`), pass the address as an explicit constructor argument instead. The CLI warns and stops when it detects this; `--force` bypasses the check.
Constructor and function arguments use forge-style syntax: space-separated, one value per argument (for example `--constructor-args 0xRecipient 1000000`). Arrays are written `[a,b]`, tuples are written `(a,b)`, and negative numbers need a leading space (for example `" -5"`).
Re-deploying the identical contract from the same app fails with `CONTRACT_ALREADY_DEPLOYED` because the CREATE2 address already has code. Passing constructor arguments to a contract that has no constructor is an error. Gas spent by `deployContract` and `writeContract` is billed on your normal Goldsky bill, the same as gas used by your deployed tasks.
### writeContract
Send a gas-sponsored transaction to a contract on any supported chain, using your app's wallet. Encodes calldata from a function signature and arguments, or accepts raw calldata. This is the same wallet identity your task code uses via `evm.wallet()`, so you can use it to trigger events, call admin functions, or make transfers without managing gas or keys. While the transaction is in flight the CLI prints `Submitting UserOp on ...`, and the result prints as soon as it lands. With `--json`, progress lines are not printed. `writeContract` works before your app's first deploy. Gas spent by `writeContract` is billed on your normal Goldsky bill, the same as gas used by your deployed tasks.
```bash theme={"dark"}
goldsky compose writeContract \
--chain-id 84532 \
--to 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 \
--function "transfer(address,uint256)" \
--args 0xRecipient 1000000
```
Options:
* `--chain-id ` Chain to transact on (required)
* `--to ` Target contract address (required)
* `--function ` Function signature, e.g. `"transfer(address,uint256)"`
* `--args ` Function arguments, space-separated (one value per argument)
* `--data ` Raw calldata hex, as an alternative to `--function` + `--args`
* `--value ` Value to send with the transaction. Accepts plain wei or an `ether`/`gwei` suffix: `1000`, `1ether`, `0.5ether`, `100gwei`
* `--wallet ` Named wallet to send from (default: `default`)
* `-m, --manifest ` Path to manifest file (default: `compose.yaml`)
* `-t, --token ` Authentication token
* `--api-server ` Override the API server URL
* `--json` Emit the transaction result as JSON
### clean
Deletes your local stage database (`.compose/stage.db`), wiping all local execution state and collection data. Prompts for confirmation unless `-f` is passed. In a non-TTY it aborts with `Use --force for non-interactive cleanup.` unless `-f` is passed.
```bash theme={"dark"}
goldsky compose clean
```
Options:
* `-f, --force` Skip the confirmation prompt
* `-c, --config ` Path to manifest file (default: `compose.yaml`)
### update \[version]
Update the Compose CLI. With no argument it updates to the latest version; pass a version to install a specific release.
```bash theme={"dark"}
# update to the latest version
goldsky compose update
# install a specific version
goldsky compose update 0.8.1
```
Options:
* `--preview` Install the latest preview build from `main` instead of the current stable release
See [Release channels](./app-configuration#release-channels) for the difference between `stable` and `preview`.
## App lifecycle
For full examples, see [App lifecycle](./app-lifecycle).
### status
Show the status of a deployed app.
```bash theme={"dark"}
goldsky compose status
```
Options:
* `-n, --name ` App name (alternative to `-m`)
* `-m, --manifest ` Path to manifest file (default: `compose.yaml`)
* `-t, --token ` Authentication token
* `--json` Emit JSON output (for scripts and agents)
### list
List all deployed apps in your project.
```bash theme={"dark"}
goldsky compose list
```
Options:
* `-t, --token ` Authentication token
* `--json` Emit JSON output
### pause
Pause a deployed app. Cron triggers stop firing and HTTP triggers return an error until the app is resumed.
```bash theme={"dark"}
goldsky compose pause
```
Options:
* `-n, --name ` / `-m, --manifest `
* `-t, --token `
* `--json`
### resume
Resume a paused app.
```bash theme={"dark"}
goldsky compose resume
```
Options: same as `pause`.
### delete
Delete a deployed app. Interactively prompts you to type the app name to confirm, then asks whether to also delete the app's hosted Postgres database (unless `--delete-database` is already set). Pass `--force` to skip both prompts (required for non-interactive use). In non-TTY environments without `--force`, the command errors out.
```bash theme={"dark"}
goldsky compose delete
```
Options:
* `-n, --name ` / `-m, --manifest `
* `-t, --token `
* `-f, --force` Skip confirmation prompts (required for non-interactive use, e.g. CI)
* `--delete-database` Also delete the app's hosted Postgres database
* `--json`
Deleting an app (and especially its database) is permanent. See [Deleting a Compose app](./deploy-monitor#deleting-a-compose-app) for the full behavior including pipeline safety checks.
### logs
View or tail logs from a deployed app.
```bash theme={"dark"}
# show the last 100 log lines
goldsky compose logs
# tail logs live, filtered to errors and warnings
goldsky compose logs -f --level error,warn
# show logs from the last hour
goldsky compose logs --since 1h
# show 500 lines and exit
goldsky compose logs --max-lines 500
```
Options:
* `-n, --name ` / `-m, --manifest `
* `-t, --token `
* `-f, --follow` Stream logs live
* `--tail ` Number of lines to fetch (default: `100`)
* `--level ` Comma-separated log levels (e.g. `error,warn`)
* `--search ` Filter log lines by text
* `--since ` Only show logs since a relative time (e.g. `1h`, `30m`, `7d`)
* `--max-lines ` Exit after N lines (useful with `-f`)
* `--timeout ` Exit after a duration (useful with `-f`)
* `--json` Emit newline-delimited JSON
## Inspecting a deployed app
These commands read back information about a deployed app. They accept the standard targeting flags (`-n, --name` or `-m, --manifest`) and `--json` unless noted.
### history
Show the deploy history for an app.
```bash theme={"dark"}
goldsky compose history
```
Options:
* `-n, --name ` / `-m, --manifest `
* `-t, --token ` Authentication token
* `--limit ` Number of records to show (default: 20, server caps at 100)
* `--offset ` Number of records to skip (default: 0)
* `--include-failures` Include failed deploys in the list
* `--json` Emit JSON output
When the list is truncated, the output prints the visible range, for example: `Showing 6-7 of 42 records. Use --limit and --offset to page.`
### runs \[runId]
List task runs for an app, or show one run's detail when you pass a run id.
```bash theme={"dark"}
# list recent runs
goldsky compose runs
# show one run's detail
goldsky compose runs 01HV8X2K1QZ9F4N1V3M2P7B6
```
Options:
* `-n, --name ` / `-m, --manifest `
* `-t, --token ` Authentication token
* `--limit ` Number of runs to show
* `--offset ` Number of runs to skip
* `--task ` Filter to runs of a single task
* `--status ` Filter by run status
* `--since ` Only show runs since a relative time (e.g. `1h`, `30m`, `7d`)
* `--until ` Only show runs before a relative time
* `--json` Emit JSON output
### collections list
List the collection names for an app.
```bash theme={"dark"}
goldsky compose collections list
```
Options:
* `-n, --name ` / `-m, --manifest `
* `-t, --token ` Authentication token
* `--json` Emit JSON output
### collections query \[collectionName]
Query documents in a collection. The collection name is required.
```bash theme={"dark"}
goldsky compose collections query prices --filter '{"symbol": "BTC"}' --limit 10
```
Options:
* `-n, --name ` / `-m, --manifest `
* `-t, --token ` Authentication token
* `--filter ` Filter documents by a JSON predicate
* `--limit ` Number of documents to return (default: 100, maximum: 1000)
* `--offset ` Number of documents to skip
* `--json` Emit JSON output
### source \[taskName]
Print the deployed source for an app. With no argument it lists the deployed files; with a task name it prints that task's source. It never writes to disk.
```bash theme={"dark"}
# list deployed files
goldsky compose source
# print one task's source
goldsky compose source price_fetcher
```
Options:
* `-n, --name ` / `-m, --manifest `
* `-t, --token ` Authentication token
* `--json` Emit JSON output
### download
Download the deployed source archive as `.zip` by default. Use `-o, --output ` to choose a destination; the command refuses to overwrite an existing file. A downloaded app runs locally as-is: `compose start` detects the pre-bundled task files and runs them without re-bundling.
```bash theme={"dark"}
goldsky compose download
goldsky compose download -o ./my-app.zip
```
Options:
* `-n, --name ` / `-m, --manifest `
* `-t, --token ` Authentication token
* `-o, --output ` Output path (default: `.zip`)
* `--json` Emit JSON output
## Wallet management
### wallet create
Create a named wallet for this app and print its address. Works before the app's first deploy, so you can create a wallet, fund it, or pass its address as a constructor argument to `deployContract` before anything is running.
```bash theme={"dark"}
# create a cloud wallet (default)
goldsky compose wallet create my_wallet
# create a local wallet in your stage DB
goldsky compose wallet create my_wallet --env local
```
Options:
* `-m, --manifest ` Path to manifest file (default: `compose.yaml`); the app name is read from here
* `--env ` Where to create the wallet (default: `cloud`)
* `-t, --token `
* `--json` Emit the wallet as JSON
The wallet address is printed to stdout so you can pipe it into other commands or scripts.
### wallet list
List wallets that have been created for this app. Returns an empty list for an app that has never deployed.
```bash theme={"dark"}
goldsky compose wallet list
goldsky compose wallet list --env local
```
Options:
* `-m, --manifest ` Path to manifest file (default: `compose.yaml`)
* `--env ` (default: `cloud`)
* `-t, --token `
* `--json` Emit the wallets as JSON
## Secrets
See [Secrets](./secrets) for the full workflow.
### secret set
Set or update a secret. See [Secrets](./secrets) for full details.
```bash theme={"dark"}
# set a cloud secret (default)
goldsky compose secret set MY_SECRET --value my-secret-value
# set a local secret (writes to .env)
goldsky compose secret set MY_SECRET --value my-secret-value --env local
# set a cloud secret and redeploy the app to pick it up
goldsky compose secret set MY_SECRET --value my-secret-value --redeploy
```
Options:
* `--value ` Secret value (required)
* `--env ` Where to store the secret (default: `cloud`)
* `--redeploy` After setting, redeploy the app so the new value takes effect
* `-n, --name ` / `-m, --manifest `
* `-t, --token `
Secret names must be SCREAMING\_SNAKE\_CASE. A running app only picks up secret changes after a redeploy: pass `--redeploy` or run `goldsky compose deploy` yourself.
### secret delete
Delete a secret.
```bash theme={"dark"}
goldsky compose secret delete MY_SECRET
goldsky compose secret delete MY_SECRET --env local
```
Options:
* `--env ` Where to delete from (default: `cloud`)
* `-n, --name ` / `-m, --manifest `
* `-t, --token `
### secret list
List the names of cloud secrets set for this app. Secret values are never shown; see [How secrets are stored](./secrets#how-secrets-are-stored).
```bash theme={"dark"}
goldsky compose secret list
```
Options:
* `-n, --name ` / `-m, --manifest `
* `-t, --token `
* `--json` Emit the secret names as JSON
# Task to Task Execution (callTask)
Source: https://docs.goldsky.com/compose/context/call-task
Invoke another task in the same Compose app with callTask, including arguments, retries, and return values.
## Cross task execution
A common pattern in compose apps is to trigger tasks from other tasks. This can be done either by creating an [HTTP trigger](../task-triggers)
and calling it with [fetch()](./fetch), or by using `callTask()`. Typically you'll want to use `callTask()`.
`callTask` invokes another task **in the same compose app**. It awaits the invoked task's `main()` function and resolves with its return value. If the invoked task throws, the error is re-thrown in the caller.
```typescript theme={"dark"}
callTask, T = unknown>(
taskName: string,
args: Args,
retryConfig?: {
max_attempts: number;
initial_interval_ms: number;
backoff_factor: number;
},
): Promise
```
* `taskName`: the `name` of a task declared in `compose.yaml`.
* `args`: a JSON-serializable payload passed to the invoked task's `main()` as its payload argument.
* `retryConfig`: optional. Overrides the invoked task's retry settings for this call.
### Basic Example
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ callTask }: TaskContext) {
const result = await callTask("my_task", { some: "payload" });
return result;
}
```
### Examples
#### Call task in a loop
```typescript highlight={18-28} theme={"dark"}
import { TaskContext } from "compose";
type MarketData = {
questionId: string;
resolved: boolean;
startTime: number;
endTime: number;
};
export async function main({ collection, callTask }: TaskContext) {
const marketsCollection = await collection("markets");
const unresolvedMarkets = await marketsCollection.findMany({ resolved: false });
const SYMBOL = "ETH-USD";
const marketDataPromises = unresolvedMarkets.map(async (market) => {
try {
const response = await callTask<{ error?: string }>("readMarketData", {
questionId: market.questionId,
symbol: SYMBOL,
startTime: market.startTime,
endTime: market.endTime,
});
return {
market,
marketData: response,
};
} catch (error) {
console.log(`Failed to read candle data for market ${market.questionId}: ${error}`);
return null;
}
});
const marketDataResults = await Promise.all(marketDataPromises);
return {
marketDataResults,
};
}
```
## Next Steps
Trigger tasks from cron, the CLI and via HTTP
You can use any sandbox compatible typescript packages with any package manager.
# State Management (collections)
Source: https://docs.goldsky.com/compose/context/collections
Persist and query state across Compose tasks and runs with MongoDB-like collection operations backed by SQLite locally and Postgres in the cloud.
Manage persistent state across tasks and task runs using MongoDB-like collection operations. Collections are where your app's stored state lives, and any task can read, write, search, and filter it at any time.
When running locally, collections use SQLite (stored in `.compose/stage.db`). When deployed, each Compose app gets its own isolated Postgres database. The API is identical in both environments.
The hosted Postgres is yours to use for application state via collections, but Compose also uses the same database internally to power durable execution (clean resumes after crashes and rolling deploys), transaction reorg monitoring, and wallet bookkeeping. Internal state lives in reserved namespaces; see [Reserved collection names](#reserved-collection-names) below.
## Examples
```typescript theme={"dark"}
import { TaskContext } from "compose";
type Dog = {
breed: string;
color: string;
};
export async function main({ collection, fetch }: TaskContext) {
const dogsCollection = await collection("dogs", [
{ path: "color", type: "text" },
]);
// Get existing state
const brownDogs = await dogsCollection.findMany({ color: "brown" });
// Get some data
const newData = await fetch("https://api.dogs.com/v1/dogs/labrador");
// Update state
await dogsCollection.insertOne(newData);
return {
success: true,
};
}
```
## Full Interface
```typescript theme={"dark"}
export type ScalarIndexType = "text" | "numeric" | "boolean" | "timestamptz";
export interface CollectionIndexSpec {
path: string;
type: ScalarIndexType;
unique?: boolean;
}
export interface FindOptions {
limit?: number;
offset?: number;
}
// Filter helpers for comparison operators
export type FilterHelper =
| "$gt"
| "$gte"
| "$lt"
| "$lte"
| "$in"
| "$ne"
| "$nin"
| "$exists";
export type HelperValue = Partial<
Record
>;
export type FilterValue = string | number | boolean | HelperValue;
export type Filter = Record;
export type WithId = T & { id: string };
export interface Collection {
readonly name: string;
insertOne(doc: TDoc, opts?: { id?: string }): Promise<{ id: string }>;
findOne(filter: Filter): Promise | null>;
findMany(filter: Filter, options?: FindOptions): Promise>>;
getById(id: string): Promise | null>;
/**
* @param opts.upsert - Defaults to true. Set to false to throw if document doesn't exist.
*/
setById(
id: string,
doc: TDoc,
opts?: { upsert?: boolean },
): Promise<{ id: string; upserted?: boolean; matched?: number }>;
deleteById(id: string): Promise<{ deletedCount: number }>;
drop(): Promise;
}
```
The `collection` function is available on `TaskContext`:
```typescript theme={"dark"}
collection: (
name: string,
indexes?: CollectionIndexSpec[],
) => Promise>;
```
## Filter operators
The `Filter` type supports comparison operators beyond simple equality:
```typescript theme={"dark"}
// Equality (default)
await dogs.findMany({ color: "brown" });
// Comparison operators
await dogs.findMany({ age: { $gt: 3 } }); // greater than
await dogs.findMany({ age: { $gte: 3 } }); // greater than or equal
await dogs.findMany({ age: { $lt: 10 } }); // less than
await dogs.findMany({ age: { $lte: 10 } }); // less than or equal
await dogs.findMany({ color: { $ne: "brown" } }); // not equal
// Set membership
await dogs.findMany({ breed: { $in: ["labrador", "golden"] } }); // in set
await dogs.findMany({ breed: { $nin: ["chihuahua"] } }); // not in set
// Field existence
await dogs.findMany({ nickname: { $exists: true } });
```
## `setById` return value
`setById` defaults to upsert behavior. The return value tells you whether the write created a new row or updated an existing one:
* `upserted: false`, `matched: 0`: the document did not exist, so a new row was inserted.
* `upserted: true`, `matched: 1`: an existing document with that `id` was updated.
Pass `{ upsert: false }` to disable insert-on-missing; `setById` will then throw if no document exists with that `id`.
## Unique fields
An index with `unique: true` on a field other than `id` rejects duplicate values. `insertOne` or `setById` throws this error when the value is already stored by another row:
```text theme={"dark"}
This value is already stored in collection 'dogs'. Unique constraint violated on a secondary field. Use that field as the row id to update the existing row.
```
The run is not retried, because retrying the same save would fail the same way. `setById` upserts on `id` only, so it never replaces a different row that holds the same unique value. To update that row, use the unique field's value as the `id`, or catch the error in your task and handle it.
## `drop()` vs `deleteById()`
`collection.drop()` runs `DROP TABLE IF EXISTS` against the backing database: it removes the collection's table entirely, not just its rows. Subsequent calls like `insertOne` do **not** automatically recreate the table; you must call `ctx.collection(name, indexes)` again to recreate it (along with its indexes).
For routine cleanup that preserves the table and its indexes, prefer `deleteById` (or iterate with `findMany` + `deleteById`). Reach for `drop()` only when you truly want to discard the collection.
## Reserved collection names
The following names are reserved for internal use and cannot be used as collection names: `wallets`, `stage`, `monitored_transactions`, `runs`, `context_functions`. Attempting to create or drop a collection with a reserved name throws an error.
## Next Steps
Interact with EVM blockchains and smart contracts.
Set and access environment variables.
# Direct SQL (db)
Source: https://docs.goldsky.com/compose/context/db
Run SQL against your Compose app's Postgres database (SQLite locally) with ctx.db.query, positional parameters, and per-schema search paths.
## Query your app's database with "db"
`ctx.db.query` lets a task run SQL directly against your Compose app's database. In the cloud this is
the hosted Postgres database that backs your app; in local dev it is the local SQLite database, so the
same task code works in both environments.
Use it for state that does not fit [collections](/compose/context/collections), for example managing
dynamic lookup tables (like a wallet tracker's address list) or maintaining your own custom schema.
### Signature
```typescript theme={"dark"}
db: {
query>(
schema: string,
sql: string,
params?: (string | number | boolean | null)[],
retryConfig?: ContextFunctionRetryConfig
): Promise>;
}
```
The result is always an object with a `rows` array:
```typescript theme={"dark"}
export type DbQueryResult> = {
rows: T[];
};
```
### The schema argument
The first argument is the Postgres schema your query runs against, and it is required. Compose sets
the schema as the `search_path` before running your query, so your SQL can reference tables in that
schema without qualifying every name.
The schemas reserved for Compose internals (`public`, `pg_catalog`, and `information_schema`) are
blocked, and the name must be a valid SQL identifier (letters, digits, and underscores, starting with
a letter or underscore). Pick a custom schema for your tables, for example `app` or `tracker`.
### Parameters
Use Postgres-native positional placeholders (`$1`, `$2`, ...) and pass values in the `params` array.
When running locally against SQLite, the placeholders are converted to `?` for you, so you can write
one query that works in both environments.
### Examples
#### Create and read a lookup table
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ db }: TaskContext) {
await db.query(
"tracker",
`CREATE SCHEMA IF NOT EXISTS tracker`,
);
await db.query(
"tracker",
`CREATE TABLE IF NOT EXISTS watched_wallets (
address text PRIMARY KEY,
added_at timestamptz DEFAULT now()
)`,
);
await db.query(
"tracker",
`INSERT INTO watched_wallets (address) VALUES ($1) ON CONFLICT DO NOTHING`,
["0x1234567890abcdef1234567890abcdef12345678"],
);
const { rows } = await db.query<{ address: string }>(
"tracker",
`SELECT address FROM watched_wallets`,
);
return rows.map((r) => r.address);
}
```
Like all context functions, `ctx.db.query` calls are logged for auditing and are deterministically
cached within a task run: if a run is interrupted and resumed, completed queries return their
cached results instead of re-executing. See [Context Functions](./overview) for details.
# Environment variables (env)
Source: https://docs.goldsky.com/compose/context/env
Expose configuration values to Compose tasks via the env field and secrets, with separate local and cloud environments.
There are two ways to expose values to your tasks: the `env` field in your [App Configuration](../app-configuration) and
[Secrets](../secrets). Both show up on the `env` property of your task context at runtime.
Only the values for the current environment are injected: when running locally, only `env.local` values are used; when deployed, only `env.cloud` values are used. They are never merged together.
If a secret has the same name as an env variable, the secret value takes precedence.
## Example
Declare environment variables and secrets in your compose.yaml:
```yaml theme={"dark"}
# compose.yaml
name: "my-app"
env:
local:
MY_VAR: "foo"
ANOTHER_VAR: "bar"
cloud:
MY_VAR: "boo"
ANOTHER_VAR: "baz"
secrets:
- MY_SECRET
tasks:
- name: "task1"
path: "./task1.ts"
```
Secrets are listed by name only. Set their values locally in a `.env` file or in the cloud with `goldsky compose secrets set`. See [Secrets](../secrets) for details.
Reference them in your tasks via the `env` property of the task context:
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ env }: TaskContext) {
console.log(env.MY_VAR);
console.log(env.ANOTHER_VAR);
console.log(env.MY_SECRET);
}
```
Trigger tasks from other tasks, creating composable workflows.
You can use any sandbox compatible typescript packages with any package manager.
# EVM chains
Source: https://docs.goldsky.com/compose/context/evm/chains
Use built-in or custom EVM chains in Compose tasks, powered by Goldsky Edge RPC.
Compose comes with built-in chain support powered by our own "Edge RPC" product for reliable, low-latency RPC access. See the full list of networks available out of the box on the [Edge RPC supported networks](/chains/supported-networks#coverage-matrix) page. Need a chain that isn't listed? Contact us at [support@goldsky.com](mailto:support@goldsky.com) and we can look into adding support.
You can access any built-in chain with `evm.chains.`. The chain keys match the exports from [`viem/chains`](https://viem.sh/docs/chains/introduction) (for example, Ethereum mainnet is `evm.chains.mainnet`, not `evm.chains.ethereum`). Compose also supports [custom chain configurations](#using-custom-chains) for any EVM network not covered by Edge RPC. See [Wallets](./wallets) and [Smart Contracts](./contracts) for more details on how chains are used.
## Using built-in chains
This is the easiest and most reliable option for most scenarios.
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm }: TaskContext) {
// the "chains" object is typed and holds all our natively supported chains
// native chains are pre-configured to use Goldsky's Edge RPC
console.log(evm.chains.base);
console.log(evm.chains.mainnet); // Ethereum mainnet
}
```
## Using custom chains
To use a custom chain, create an object that fulfills our `Chain` interface.
```typescript theme={"dark"}
import { TaskContext, Chain } from "compose";
export async function main({ evm, env }: TaskContext) {
// custom chain spec
const myCustomChain: Chain = {
id: 480,
name: "My Custom Chain",
testnet: false,
nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
rpcUrls: {
default: { http: [`https://mycustomchain-mainnet.g.alchemy.com/v2/${env.MY_CUSTOM_CHAIN_API}`] },
public: { http: ["https://mycustomchain-mainnet.g.alchemy.com/public"] },
},
blockExplorers: {
default: { name: "myCustomChainScan", url: "https://myCustomChainScan.org" },
},
};
// you can now use the myCustomChain const anywhere you'd use a built-in chain (see Wallets and Smart Contracts for details)
console.log(myCustomChain);
}
```
The `Chain` type is available from the `TaskContext` interface. Here it is for reference:
```typescript theme={"dark"}
export type Chain = {
id: number;
name: string;
testnet: boolean;
nativeCurrency: {
name: string;
symbol: string;
decimals: number;
};
rpcUrls: {
public: { http: string[] };
default: { http: string[] };
};
blockExplorers: {
default: { name: string; url: string };
};
contracts?: Record;
};
```
# EVM smart contracts
Source: https://docs.goldsky.com/compose/context/evm/contracts
Interact with smart contracts from Compose tasks using type-safe classes generated from your ABIs.
Compose lets you interact with smart contracts with type safety and your choice of wallet. See [wallets](./wallets) for details on the different types of wallets.
## Code generation
To interact with smart contracts with full type safety, place your ABI JSON files in the `src/contracts/` folder. Compose automatically generates TypeScript classes when you run `compose start` or `compose deploy`.
You can also manually trigger code generation:
```bash theme={"dark"}
compose codegen
```
The generated file is written to `.compose/generated/index.js`. On `compose deploy`, the CLI bundles this file alongside your tasks so the same typed classes are available in the cloud.
If you deploy your contract with [`compose deployContract`](../../cli-reference#deploycontract), the CLI writes its ABI to `src/contracts/` for you, so you can run `compose codegen` immediately afterward.
### Generated classes
For each ABI file (e.g., `src/contracts/BitcoinOracleContract.json`), Compose generates a typed class that you can access via `evm.contracts`:
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
const wallet = await evm.wallet({ name: "my-wallet" });
// Access the generated contract class via evm.contracts
const bitcoinOracleContract = new evm.contracts.BitcoinOracleContract(
env.ORACLE_ADDRESS as `0x${string}`,
evm.chains.base,
wallet
);
// Convert timestamp and price to bytes32 format
const timestamp = Date.now();
const bitcoinPrice = 65000;
const timestampAsBytes32 = `0x${timestamp.toString(16).padStart(64, "0")}`;
const priceAsBytes32 = `0x${Math.round(bitcoinPrice * 100).toString(16).padStart(64, "0")}`;
// Call a state-changing method — returns { hash, receipt, userOpHash? }
const { hash } = await bitcoinOracleContract.setPrice(
timestampAsBytes32,
priceAsBytes32
);
// Call a view method — returns the decoded value directly
const result = await bitcoinOracleContract.getLatestPrice();
}
```
Contract methods are called directly on the instance without `.write` or `.read` suffixes. View/pure functions return their decoded value directly, while state-changing functions return `{ hash, receipt, userOpHash? }` (the `userOpHash` is present only when gas sponsoring routes the transaction through a bundler).
## Decoding event logs
Each generated contract class includes a static `decodeEventLog()` method for decoding onchain events with full type safety. This is commonly used in tasks triggered by [onchain events](../../task-triggers#chain-event-triggers):
```typescript theme={"dark"}
import { TaskContext, OnchainEvent } from "compose";
export async function main({ evm }: TaskContext, payload: OnchainEvent) {
// Decode using a generated contract class — returns a typed union of all events in the ABI
const decoded = await evm.contracts.MyContract.decodeEventLog(payload);
if (decoded.eventName === "Transfer") {
console.log("Transfer:", decoded.args);
}
// Or use the top-level decodeEventLog with any ABI
const myAbi = [/* ... */];
const decoded2 = await evm.decodeEventLog(myAbi, payload);
}
```
You can also use `decodeEventLog` with a generic type parameter for a single known event type:
```typescript theme={"dark"}
const decoded = await evm.contracts.MyContract.decodeEventLog(payload);
```
## Direct wallet methods
You can also interact with contracts directly through wallet methods without generated classes. This is useful for one-off calls or contracts you don't want to check an ABI into the repo for:
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
const wallet = await evm.wallet({ name: "my-wallet" });
// Write to a contract — returns { hash, receipt, userOpHash? }
const { hash, receipt } = await wallet.writeContract(
evm.chains.polygon,
env.CONTRACT_ADDRESS as `0x${string}`,
"reportPayouts(bytes32,uint256[])",
[resultId, payouts]
);
// Read from a contract — returns the decoded value directly
const balance = await wallet.readContract(
evm.chains.polygon,
env.CONTRACT_ADDRESS as `0x${string}`,
"balanceOf(address) returns (uint256)",
[wallet.address]
);
}
```
See the [wallets documentation](./wallets) for the full `writeContract`, `readContract`, and `sendTransaction` signatures, gas handling, confirmations, and reorg protection options.
# EVM context overview
Source: https://docs.goldsky.com/compose/context/evm/overview
Overview of the Compose evm context for chains, wallets, contracts, and reorg-aware transactions.
## Blockchain interactions
Compose apps orchestrate and react to on-chain activity from off-chain logic. The `evm` context
provides the tools for that: `evm.chains` for chain configuration, `evm.wallet()` and `evm.webhookWallet()` for wallets,
and `evm.contracts` for type-safe contract interactions. See the individual sections below for full detail on each.
1. [Chains](./chains)
2. [Wallets](./wallets)
3. [Smart Contracts](./contracts)
4. [Reorg Handling](./reorgs)
# EVM reorg handling
Source: https://docs.goldsky.com/compose/context/evm/reorgs
Wait for confirmations and handle mempool eviction or reorgs automatically when sending transactions from Compose tasks.
Compose handles mempool eviction and re-orgs for you, without bespoke monitoring code.
Both `wallet.writeContract()` and `wallet.sendTransaction()` support confirmation and reorg handling.
This page covers transactions your task **sends**. For reorg safety on the events that **trigger** your task, use `confirmations` on the onchain trigger — see [Confirmations](../../task-triggers#confirmations).
## Confirmations
By default all transactions via `wallet.writeContract()` or state-changing methods on [contracts](./contracts) will wait for one confirmation before
resolving the method's promise. This means that the transaction will be seen in at least one block by the time your task execution advances. You
can configure this further with the optional `TransactionConfirmation` logic. If your transaction doesn't make it into the number of blocks specified
the context function call will fail and retry logic will kick in. If it still doesn't make it into the desired number of blocks after retries are exhausted
then the promise will reject.
Here's an example for both `wallet.writeContract()` and on a contract class method:
```typescript highlight={18} theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
const wallet = await evm.wallet();
const resultId = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
const payouts = [1000n, 2000n, 3000n];
const { hash } = await wallet.writeContract(
evm.chains.polygon,
env.CONTRACT_ADDRESS as `0x${string}`,
"reportPayouts(bytes32,uint256[])",
[resultId, payouts],
{
// this will not resolve the promise until the transaction has been seen in 5 blocks
// if the transaction doesn't make it into five blocks (maybe is evicted from mempool, etc),
// then your retry config will determine whether to retry the transaction
confirmations: 5,
},
{
max_attempts: 5,
initial_interval_ms: 1000,
backoff_factor: 2,
}
);
}
```
## Reorgs
Reorgs could revert your transaction after the promise is resolved and the confirmations are all seen. For example, if you have 5 confirmations
but later on a 100 block reorg occurs, you can configure your transaction with various retry "behaviors" to handle that situation. Like with confirmations,
reorg handling can be used both with `wallet.writeContract()` as well as any state-changing methods on a [smart contract class](./contracts).
There are several behaviors that we support currently:
| behavior | description | other params |
| - | - | - |
| replay | re-executes transaction with fresh gas parameters and nonce (recalculated at replay time) | n/a |
| log | just logs the reorg to your standard app logs | logLevel (optional) |
| task | calls a compose task of yours for custom handling | task (name of compose task) |
### Examples
```typescript highlight={17-24,42-49,67-74} theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
const wallet = await evm.wallet();
const resultId = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
const payouts = [1000n, 2000n, 3000n];
// Replay on reorg
const { hash } = await wallet.writeContract(
evm.chains.polygon,
env.CONTRACT_ADDRESS as `0x${string}`,
"reportPayouts(bytes32,uint256[])",
[resultId, payouts],
{
confirmations: 5,
onReorg: {
action: {
// this will replay the transaction with a fresh nonce and gas if the transaction is reorged off chain after the 5 confirmations specified below
// it will then start watching again for the number of blocks specified in the "depth" property
type: "replay",
},
// we'll watch this transaction in the background for 200 blocks and replay it if the transaction receipt disappears
depth: 200,
},
},
{
max_attempts: 5,
initial_interval_ms: 1000,
backoff_factor: 2,
}
);
// Log on reorg
const { hash: hash2 } = await wallet.writeContract(
evm.chains.polygon,
env.CONTRACT_ADDRESS as `0x${string}`,
"reportPayouts(bytes32,uint256[])",
[resultId, payouts],
{
confirmations: 5,
onReorg: {
action: {
// this will just log in your normal app logs if the transaction is reorged off chain after the 5 confirmations specified below
type: "log",
logLevel: "warn", // defaults to "error"
},
// we'll watch this transaction in the background for 200 blocks and log if the transaction receipt disappears
depth: 200,
},
},
{
max_attempts: 5,
initial_interval_ms: 1000,
backoff_factor: 2,
}
);
// Custom task on reorg
const { hash: hash3 } = await wallet.writeContract(
evm.chains.polygon,
env.CONTRACT_ADDRESS as `0x${string}`,
"reportPayouts(bytes32,uint256[])",
[resultId, payouts],
{
confirmations: 5,
onReorg: {
action: {
// this will send the transaction as a payload to the specified task if the transaction is reorged off chain after the 5 confirmations specified below
type: "task",
task: "reorg-reconciler", // the name of your compose task with custom re-org handling logic
},
// we'll watch this transaction in the background for 200 blocks and call your "reorg-reconciler" if the transaction receipt disappears
depth: 200,
},
},
{
max_attempts: 5,
initial_interval_ms: 1000,
backoff_factor: 2,
}
);
}
```
Monitored transactions are checked for reorgs every 5 minutes. When a reorg is detected and the `replay` action is configured, the transaction is re-submitted with fresh gas parameters and nonce (not the original values, since the post-reorg state may differ).
## Full TransactionConfirmation type
```typescript theme={"dark"}
export type ReplayOnReorg = {
type: "replay";
};
export type LogOnReorg = {
type: "log";
logLevel?: "error" | "info" | "warn"; // defaults to "error"
};
export type CustomReorgAction = {
type: "task";
// your task will be sent with a payload the full transaction minus gas and nonce
task: string;
};
export type OnReorgOptions = ReplayOnReorg | LogOnReorg | CustomReorgAction;
export type OnReorgConfig = {
action: OnReorgOptions;
depth: number;
};
export interface TransactionConfirmation {
// this the number of block confirmations before we resolve the promise
// i.e. "wait 5 blocks before proceeding to the next step in my task"
confirmations?: number;
onReorg?: OnReorgConfig;
}
```
# EVM wallets
Source: https://docs.goldsky.com/compose/context/evm/wallets
Create and use Compose smart wallets, EOA private-key wallets, webhook wallets, and impersonated wallets for blockchain transactions.
There are several types of wallets and wallet behaviors that compose supports.
## Smart wallets
If you just need to interact with smart contracts, the easiest option is one of our smart wallets. You'll be able to see
all of your wallets in the dashboard at `https://app.goldsky.com/{projectId}/dashboard/compose/{appName}`.
### Create a smart wallet
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
// this is idempotent so the wallet is only created the first time this is called and is "retrieved" after that.
// passing no args will create a "default" wallet for your app
const wallet = await evm.wallet();
console.log(wallet.address);
// you can create multiple named wallets too. This will generate multiple saved smart wallets that can be referenced by name in different
// tasks and task runs
const walletOne = await evm.wallet({ name: "wallet-one" });
const walletTwo = await evm.wallet({ name: "wallet-two" });
// private key wallet
const privateKeyWallet = await evm.wallet({ privateKey: env.MY_KEY });
// now you can use these wallet to make transactions (see below for details)
}
```
### Using wallets
Once you have a wallet created you can use it to write to smart contracts, see the full [smart contract docs](./contracts) for more details
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env, fetch }: TaskContext) {
const wallet = await evm.wallet();
const response = await fetch<{ bitcoin: { usd: number } }>(
"https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd"
);
// Convert timestamp and price to bytes32 format
const timestamp = Date.now();
const bitcoinPrice = response.bitcoin.usd;
const timestampAsBytes32 = `0x${timestamp.toString(16).padStart(64, "0")}`;
const priceAsBytes32 = `0x${Math.round(bitcoinPrice * 100).toString(16).padStart(64, "0")}`;
const bitcoinOracleContract = new evm.contracts.BitcoinOracleContract(
env.ORACLE_ADDRESS,
evm.chains.base,
wallet
);
const { hash } = await bitcoinOracleContract.setPrice(
timestampAsBytes32,
priceAsBytes32
);
}
```
You can also make or simulate transactions with methods on the Wallet class:
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
const wallet = await evm.wallet();
const resultId = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
const payouts = [1000n, 2000n, 3000n];
const { hash, receipt, userOpHash } = await wallet.writeContract(
evm.chains.polygon,
env.CONTRACT_ADDRESS as `0x${string}`,
"reportPayouts(bytes32,uint256[])",
[resultId, payouts],
{
confirmations: 3, // this will not resolve the promise until the transaction has been seen in 3 blocks
onReorg: {
// this will replay the transaction with new nonce and new gas if it's reorged later on after the three confirmations have passed
// see "Reorg Handling" for more info
action: {
type: "replay",
},
depth: 200,
},
}
);
// userOpHash is set for gas-sponsored transactions (ERC-4337 UserOperation hash)
// useful for debugging on bundler explorers
if (userOpHash) {
console.log(`UserOp hash: ${userOpHash}`);
}
}
```
### sendTransaction
For lower-level control, use `sendTransaction` to send a transaction with pre-encoded calldata. This is useful when you need to encode the transaction data yourself, pass specific gas parameters, or interact with contracts in ways that `writeContract` doesn't cover.
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
const wallet = await evm.wallet();
// encode your calldata however you like
const data = "0x..." as `0x${string}`;
const { hash, receipt } = await wallet.sendTransaction(
{
to: env.CONTRACT_ADDRESS as `0x${string}`,
data,
chain: evm.chains.ethereum,
},
{ confirmations: 3 }
);
console.log(`Transaction confirmed: ${hash}, status: ${receipt.status}`);
}
```
You can also pass explicit gas parameters for full control over fees and gas limits:
```typescript theme={"dark"}
const { hash, receipt } = await wallet.sendTransaction(
{
to: env.CONTRACT_ADDRESS as `0x${string}`,
data,
chain: evm.chains.ethereum,
value: 0n, // ETH value to send with the transaction
gas: 500000n, // gas limit
maxFeePerGas: 30000000000n, // EIP-1559 max fee per gas
maxPriorityFeePerGas: 1000000000n, // EIP-1559 priority fee
nonce: 42, // explicit nonce (EOA wallets only)
},
{
confirmations: 5,
onReorg: {
depth: 200,
action: { type: "replay" },
},
}
);
```
The `nonce` parameter is only supported with EOA (private key) wallets. Smart wallets manage nonces internally.
### writeContractBatch
`writeContractBatch` sends several contract calls in one gas-sponsored transaction. The batch is all or nothing: if any call reverts, none of them take effect. Inside each call, `msg.sender` is your wallet, so it works for methods that check the caller.
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
const wallet = await evm.wallet();
const { hash, receipt, userOpHash } = await wallet.writeContractBatch(
evm.chains.base,
[
{
address: env.TOKEN_ADDRESS as `0x${string}`,
functionSig: "approve(address,uint256)",
args: [env.SPENDER_ADDRESS, 1000n],
},
{
address: env.VAULT_ADDRESS as `0x${string}`,
functionSig: "deposit(uint256)",
args: [1000n],
value: 0n, // optional, wei to send with this call
},
],
{ confirmations: 3 }
);
console.log(`Batch confirmed: ${hash}, status: ${receipt.status}`);
}
```
Each call takes an `address`, a `functionSig`, an `args` array, and an optional `value` in wei. The second argument to `writeContractBatch` is a list of these calls. The optional third argument is the same [confirmation](./reorgs) object as `writeContract`, and the optional fourth is a retry config. It returns `{ hash, receipt, userOpHash }` for the one transaction that carried the whole batch.
`writeContractBatch` throws when:
* The wallet is not gas-sponsored, or the app is running locally or with `--fork-chains`. It only runs in deployed apps.
* The list of calls is empty.
* You pass `onReorg` in the confirmation config. Batches do not support reorg handling. `confirmations` works.
* A call would revert, or the transaction reverts on-chain. None of the calls take effect.
If a task retries after a crash, the retry resumes the first attempt's batch instead of building a new one.
Use `writeContractBatch` when calls must land together or not at all. If your calls are independent, send them as separate `writeContract` calls at the same time instead. Compose [packs those automatically](#concurrent-writes).
### getBalance
Check the native token balance of any wallet:
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm }: TaskContext) {
const wallet = await evm.wallet();
// Returns balance in wei as a string
const balance = await wallet.getBalance(evm.chains.ethereum);
console.log(`Balance: ${balance} wei`);
}
```
### Wallet properties
Every wallet exposes `name` and `address` as read-only properties:
```typescript theme={"dark"}
const wallet = await evm.wallet({ name: "my-wallet" });
console.log(wallet.name); // "my-wallet"
console.log(wallet.address); // "0x..."
```
## EOA wallets
You can also use EOAs that you already own. With an EOA you can self-fund gas, send and receive tokens in your tasks, and interact with smart contracts
where your EOA has privileges on particular contract methods. Currently we support storing your EOA private key in Compose's secret
management system, but in the future you'll be able to use private keys that are secured within TEEs. EOA wallets never pass their private keys outside of
the task process and they sign requests passed in unsigned from the host process. When tasks run in TEEs, the private key will stay inside the TEE,
never exposed to any other part of the stack.
First, you'll need to store the private key in Goldsky's secret management system and reference it in your compose.yaml file. You can see details on
how to do that in the [Secrets docs](../../secrets). Once you have your private key secret stored, you can use it to create a wallet:
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
const privateKeyWallet = await evm.wallet({ privateKey: env.MY_PRIVATE_KEY_SECRET });
// now you can use the wallet the same as any other wallet
}
```
## Webhook wallets
`evm.webhookWallet` sends gas-sponsored transactions from an address you already hold. Compose never sees the private key. It builds the ERC-4337 UserOperation, including paymaster data, POSTs that payload to a signing URL you host, then submits the signed operation.
### Create a webhook wallet
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
const wallet = await evm.webhookWallet({
url: env.SIGN_WEBHOOK_URL,
address: env.WALLET_ADDRESS as `0x${string}`,
headers: { Authorization: `Bearer ${env.SIGN_WEBHOOK_TOKEN}` },
name: "treasury", // optional; defaults to webhook:
});
const { hash, userOpHash } = await wallet.writeContract(
evm.chains.base,
env.CONTRACT_ADDRESS as `0x${string}`,
"setPrice(uint256)",
[1234n],
);
}
```
`url` must be `http://` or `https://`. `address` must be a 20-byte hex address. `headers` are copied onto every POST. Store the URL, address, and any auth token as [secrets](../../secrets).
Compose saves the address on the app, so the wallet shows up in the dashboard.
Webhook wallets implement the same `IWallet` as smart wallets and EOAs (`writeContract`, `writeContractBatch`, `sendTransaction`, `readContract`, `simulate`, `getBalance`). Writes are always gas-sponsored.
### Cloud only
Webhook wallets run in deployed apps. Creating one in local dev throws:
```
Webhook wallets are only available in cloud deployments. Restart with --fork-chains to exercise the signing callback locally.
```
`--fork-chains` still POSTs to your webhook so you can test signing. Submit fails after that because there is no local bundler.
### Request bodies
Compose POSTs JSON to `url` with `Content-Type: application/json` plus any `headers` you set. The request times out after 120 seconds. Bigint fields in the body are sent as decimal strings.
If the wallet is not yet EIP-7702 delegated on the target chain, Compose asks the webhook to sign the authorization first:
```json theme={"dark"}
{
"type": "signAuthorization",
"address": "0xYourWallet",
"chainId": 8453,
"authorizationRequest": {
"contractAddress": "0x7702Implementation",
"chainId": 8453,
"nonce": 0
}
}
```
Respond with `r` and `s` as 32-byte hex strings, and either `yParity` (`0` or `1`) or `v` (`27`, `28`, `0`, or `1`). If you also return `address`, `chainId`, or `nonce`, they must match the request. `contractAddress` is the EIP-7702 implementation, not your wallet.
Every sponsored write then asks the webhook to sign the UserOperation's EIP-712 typed data:
```json theme={"dark"}
{
"type": "signUserOperation",
"address": "0xYourWallet",
"chainId": 8453,
"userOpTypedData": {}
}
```
Respond with `{ "signature": "0x..." }`. A non-JSON body, a missing `signature`, or a non-2xx status fails the task. Do not broadcast from the webhook. Return the signature; Compose submits the sponsored UserOperation.
`nonce` on `sendTransaction` is ignored, as with other gas-sponsored wallets. A task retry prepares a new UserOperation, so Compose does not reuse a previous webhook signature.
### Signing server
The other side of `webhookWallet` is one POST handler on a server you host. `sign7702Authorization` and `signTypedData` are whatever holds the key (Turnkey, Fireblocks, an HSM, a local key). Sign and return. Do not broadcast.
```typescript theme={"dark"}
// POST /
async function handleSign(req) {
const body = await req.json();
if (body.type === "signAuthorization") {
const { contractAddress, chainId, nonce } = body.authorizationRequest;
const { r, s, yParity } = await sign7702Authorization({
address: body.address, // the wallet
contractAddress, // 7702 implementation, not the wallet
chainId,
nonce,
});
return json({ r, s, yParity }); // v: 27|28 also works
}
if (body.type === "signUserOperation") {
const signature = await signTypedData({
address: body.address,
...body.userOpTypedData, // EIP-712 from Compose
});
return json({ signature }); // 0x...
}
return status(400);
}
```
## Impersonated wallets
When testing locally with `--fork-chains`, you may need to call contract methods that are restricted to a specific address, for example an owner-only admin function or a method guarded by an access control list. Normally you'd need the private key for that address, but with the `--impersonate` flag you can act as any address on the local TEVM fork using only its public address.
This is useful when:
* You want to test privileged contract methods without giving your local environment access to the private key
* You need to debug interactions with a contract where only a specific address has permission to call certain methods
* You're testing against a forked mainnet contract and want to simulate actions from an address you control on-chain but don't want to expose the key locally
### Usage
Pass `--impersonate` alongside `--fork-chains` when starting your app. The flag takes a comma-separated list of `walletName=address` mappings:
```bash theme={"dark"}
goldsky compose start --fork-chains --impersonate "my-wallet=0x1234...abcd"
```
You can impersonate multiple wallets at once:
```bash theme={"dark"}
goldsky compose start --fork-chains --impersonate "admin=0xAdminAddr,treasury=0xTreasuryAddr"
```
Your task code stays exactly the same: reference the wallet by name as usual. The wallet's `.address` will resolve to the impersonated address, and all contract interactions (reads, writes, and simulations) will execute as that address on the local fork.
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm }: TaskContext) {
// When started with --impersonate "admin=0xOwnerAddress",
// this wallet's .address will be 0xOwnerAddress
const wallet = await evm.wallet({ name: "admin" });
console.log(wallet.address); // 0xOwnerAddress
// This call executes as the impersonated address on the fork,
// so owner-only methods will succeed
const { hash } = await wallet.writeContract(
evm.chains.base,
"0xMyContract..." as `0x${string}`,
"adminFunction(uint256)",
[42n]
);
}
```
Impersonation also works with private-key wallets. If a private-key wallet has a `name` that matches an entry in the impersonate map, the impersonated address takes precedence and the private key is effectively ignored on the fork:
```typescript theme={"dark"}
const wallet = await evm.wallet({
name: "my-pk-wallet",
privateKey: env.MY_KEY,
});
// With --impersonate "my-pk-wallet=0xTargetAddr",
// wallet.address is 0xTargetAddr, not the address derived from MY_KEY
```
`--impersonate` requires `--fork-chains` and only works in local development. All impersonated transactions execute on your local TEVM fork. Nothing is sent to the actual chain. When you deploy to cloud, wallets resolve normally.
## Gas sponsoring
By default, smart wallets (wallets created without a private key) use gas sponsoring so you don't have to manage gas funding.
Smart wallets use EIP-7702 delegation for account abstraction, with gas costs handled through ERC-4337 UserOperations.
Webhook wallets are always gas-sponsored.
You pay the gas bill as part of your normal monthly Goldsky bill, avoiding the complex budgetary and tax issues of purchasing gas tokens.
When you don't use gas sponsoring, you'll need to get your wallet address from the compose dashboard at `https://app.goldsky.com/{projectId}/dashboard/compose/{appName}`
and then transfer gas tokens to that wallet through a wallet or an exchange.
### Gas sponsoring with EOA (private key) wallets
You can also opt into gas sponsoring for EOA wallets by passing `sponsorGas: true` when creating the wallet. Compose delegates the EOA via EIP-7702 on first use and routes transactions through ERC-4337 UserOperations, just like smart wallets: you keep full control of the key and signing, but you don't have to fund the wallet with native gas tokens.
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
const wallet = await evm.wallet({
privateKey: env.MY_PRIVATE_KEY,
sponsorGas: true,
});
// transactions now go through the sponsored UserOp flow
// you pay for gas on your monthly Goldsky bill instead of from this EOA
}
```
Sponsored EOA transactions only run in deployed apps. Running with `sponsorGas: true` locally will throw a clear error that tells you to either remove `sponsorGas`, fund the wallet manually, or re-run with `--fork-chains` to exercise the sponsored flow against a forked chain. In `--fork-chains` mode the transaction is executed against the local fork (where gas is free), and you'll see a warning reminding you the sponsored flow only takes effect once deployed to cloud.
### Concurrent writes
In a deployed app, gas-sponsored `writeContract` and `sendTransaction` calls from the same wallet are queued and packed together into fewer transactions. You don't change any code. A task can start many writes at once and they finish much faster than if you await them one by one:
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
const wallet = await evm.wallet();
const ids = ["0x01", "0x02", "0x03"];
await Promise.all(
ids.map((id) =>
wallet.writeContract(
evm.chains.polygon,
env.CONTRACT_ADDRESS as `0x${string}`,
"resolve(bytes32)",
[id]
)
)
);
}
```
What to know:
* **Calls must not depend on each other.** Compose decides how calls are packed, so do not rely on their order. Use [`writeContractBatch`](#writecontractbatch) when they must land together or not at all.
* **Reverting calls fail fast.** Before packing, Compose checks each call. A call that would revert throws with the revert reason and is never sent, so it costs no gas. The other calls in the same burst still go through.
* **Packed calls share a transaction.** Calls that land together return the same `hash`, `userOpHash`, and `receipt`.
* **Confirmation settings split batches.** Writes with different `confirmations` or `onReorg` settings are packed separately, and each call resolves after its own confirmation depth.
* **Do follow-up work after the writes settle.** If each concurrent branch makes more context calls after its write, those calls can happen in a different order when the run replays. Await all the writes first, then do the follow-up calls.
### Retries and restarts
A gas-sponsored write never lands twice when a task retries or an app restarts. If a retry finds that the original write already landed, it returns the original `hash` and `receipt` instead of failing.
### Backup bundler
If the main bundler for a chain is down, Compose switches gas-sponsored writes on that chain to a backup bundler for 15 minutes, then tries the main one again. Your task code does not change. This applies on chains where a backup bundler is available.
### Gas usage in the dashboard
Every sponsored or self-paid transaction emits a run event with `evm.gas_used` and `evm.total_cost_wei` attributes (both decimal strings in wei) so you can audit per-transaction gas spend from the Compose dashboard at `https://app.goldsky.com/{projectId}/dashboard/compose/{appName}`. On OP Stack L2s (Base, Optimism, and friends) `evm.total_cost_wei` includes the L1 data fee, which typically dominates the total cost. Reading `gasUsed × effectiveGasPrice` from the receipt alone will under-report by roughly two orders of magnitude.
## Gas pricing
For non-sponsored transactions, Compose uses automatic gas estimation with sensible defaults. If you need precise control over gas parameters, use [`sendTransaction`](#sendtransaction) instead of `writeContract` and specify `maxFeePerGas`, `maxPriorityFeePerGas`, and `gas` explicitly.
`writeContract` automatically simulates the transaction before submitting it, catching revert errors early. Gas-sponsored `sendTransaction` calls in a deployed app are also checked before they are sent, and a call that would revert throws without spending gas. Self-funded `sendTransaction` calls are not simulated: they submit directly.
#### Override default gas sponsoring behavior
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
// disable gas sponsoring on a smart wallet (default is true for smart wallets)
const smartWallet = await evm.wallet({ name: "self-funded", sponsorGas: false });
// enable gas sponsoring on an EOA wallet (default is false for EOA wallets)
const sponsoredEoa = await evm.wallet({
privateKey: env.MY_PRIVATE_KEY,
sponsorGas: true,
});
}
```
## Full wallet interface
```typescript theme={"dark"}
export interface WalletConfig {
name?: string; // defaults to "default"
privateKey?: string;
sponsorGas?: boolean; // defaults to true if no privateKey and false if privateKey
}
export interface WebhookWalletConfig {
url: string; // http(s) signing webhook
address: Address;
headers?: Record;
name?: string; // defaults to webhook:
}
export interface ContractCall {
address: `0x${string}`;
functionSig: string;
args: unknown[];
value?: bigint; // wei sent with this call, defaults to 0n
}
export interface IWallet {
readonly name: string;
readonly address: `0x${string}`;
writeContract(
chain: Chain,
contractAddress: `0x${string}`,
functionSig: string,
args: unknown[],
confirmation?: TransactionConfirmation,
retryConfig?: ContextFunctionRetryConfig
): Promise<{
hash: string;
receipt: TransactionReceipt;
userOpHash?: string; // set for gas-sponsored transactions (ERC-4337)
}>;
readContract(
chain: Chain,
contractAddress: `0x${string}`,
functionSig: string,
args: unknown[],
retryConfig?: ContextFunctionRetryConfig
): Promise;
sendTransaction(
config: {
to: `0x${string}`;
data: `0x${string}`;
chain: Chain;
value?: bigint;
maxFeePerGas?: bigint;
maxPriorityFeePerGas?: bigint;
gas?: bigint;
nonce?: number;
},
confirmation?: TransactionConfirmation,
retryConfig?: ContextFunctionRetryConfig
): Promise<{
hash: string;
receipt: TransactionReceipt;
userOpHash?: string; // set for gas-sponsored transactions (ERC-4337)
}>;
// One gas-sponsored transaction, all or nothing. Sponsored wallets in deployed apps only.
// onReorg is not supported.
writeContractBatch(
chain: Chain,
calls: ContractCall[],
confirmation?: TransactionConfirmation,
retryConfig?: ContextFunctionRetryConfig
): Promise<{
hash: string;
receipt: TransactionReceipt;
userOpHash?: string; // ERC-4337 UserOperation hash
}>;
simulate(
chain: Chain,
contractAddress: `0x${string}`,
functionSig: string,
args: unknown[],
retryConfig?: ContextFunctionRetryConfig
): Promise;
getBalance(
chain: Chain,
retryConfig?: ContextFunctionRetryConfig
): Promise; // native token balance in wei
}
```
# HTTP Requests (fetch)
Source: https://docs.goldsky.com/compose/context/fetch
Make auditable HTTP requests from Compose tasks with built-in caching, retries, and OpenTelemetry spans.
## Auditable HTTP Requests with "fetch"
Make HTTP requests that are recorded as spans on the task run. This is how Compose apps interact with
off-chain systems: every `ctx.fetch` call, its URL, and its response are captured in the run's event
log, so the behavior of your app is auditable after the fact. For example, if you have an oracle that
is advertised as being driven by an aggregate of several well-known price feeds, users of dApps built
with it can audit the calls made to determine their prices and check that the price logic works
as advertised.
`ctx.fetch` wraps the native `fetch` and adds a few Compose-specific behaviors: the response is
parsed as JSON (with a text fallback), each call is recorded as an OpenTelemetry span, successful
results are cached by a deterministic idempotency key so replays after a crash don't re-hit the
remote server, and the request runs on a dedicated HTTP client pool isolated from Compose's
internal traffic.
```typescript theme={"dark"}
fetch(
url: string,
fetchConfigOrRetryConfig?: FetchConfig | ContextFunctionRetryConfig,
retryConfig?: ContextFunctionRetryConfig
): Promise
```
Where `FetchConfig` is:
```typescript theme={"dark"}
export interface FetchConfig {
method?: string;
headers?: Record;
body?: Record | string;
}
```
And `ContextFunctionRetryConfig` is:
```typescript theme={"dark"}
type ContextFunctionRetryConfig = {
max_attempts: number;
initial_interval_ms: number;
backoff_factor: number;
};
```
`ctx.fetch` retries GET, HEAD, and OPTIONS requests by default (`max_attempts` defaults to `3`, `initial_interval_ms` to `500`, and `backoff_factor` to `2`). POST, PUT, PATCH, and DELETE default to a single attempt because they are not assumed idempotent. To override either, pass a `ContextFunctionRetryConfig` explicitly, as in the "Request with Custom Retry Configuration" example below.
### Response handling
`ctx.fetch` reads the response body as JSON and returns the parsed object. If the body is not valid
JSON, it falls back to returning the raw text. Non-2xx responses throw an error that includes the
status code, status text, and response body, so you do not need to check `response.ok` yourself.
Because of this, the return type is the decoded body, not a `Response` object.
### Examples
#### Basic GET Request
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ fetch }: TaskContext) {
const data = await fetch("https://api.example.com/data");
return data;
}
```
#### POST Request with JSON Body
If `body` is an object, `ctx.fetch` JSON-encodes it for you. Pass a string if you want to send a raw
body (e.g. form-encoded or pre-serialized JSON).
To call another task in the same app, use [`ctx.callTask`](./call-task). You don't need to go
through HTTP unless you're hitting an [HTTP-triggered task](../task-triggers) externally.
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ fetch }: TaskContext) {
const result = await fetch("https://api.example.com/submit", {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: "Bearer token123",
},
body: {
name: "John Doe",
email: "john@example.com",
},
});
return result;
}
```
#### Request with Custom Retry Configuration
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ fetch }: TaskContext) {
const data = await fetch(
"https://unreliable-api.com/data",
{
method: "GET",
headers: { "User-Agent": "Compose/1.0" },
},
{
max_attempts: 5,
initial_interval_ms: 2000,
backoff_factor: 1.5,
}
);
return data;
}
```
## Next Steps
Manage state across tasks and task runs with collections.
Interact with EVM blockchains and smart contracts.
# ctx.hypercore: trade and deploy on Hyperliquid HyperCore
Source: https://docs.goldsky.com/compose/context/hypercore
Use ctx.hypercore in a Compose task to read HyperCore state and send orders, transfers, staking, subaccount, vault, and HIP-3/HIP-4 market actions.
## Trade and deploy on HyperCore with "hypercore"
`ctx.hypercore` lets a task read from and act on **HyperCore**, the native Hyperliquid exchange:
place and cancel orders, move funds, stake, manage subaccounts and vaults, operate HIP-3 perp
markets, and deploy and settle HIP-4 outcome markets.
HyperCore is not an EVM chain. Actions are signed payloads posted to Hyperliquid's exchange
endpoint, not transactions. HyperEVM, the EVM chain that runs alongside it, is served by
[`ctx.evm`](/compose/context/evm/overview) like any other chain. Use `ctx.hypercore` for the
exchange itself and `ctx.evm` for contracts on HyperEVM.
Wallets come from [`ctx.evm.wallet`](/compose/context/evm/wallets): Hyperliquid accounts are
ordinary Ethereum keypairs, so the same wallet object signs both.
```typescript theme={"dark"}
const wallet = await ctx.evm.wallet({ name: "trading-wallet" });
const mids = await ctx.hypercore.info.allMids("mainnet");
await ctx.hypercore.trade.order("mainnet", wallet, {
orders: [{
a: 0, // asset index (BTC)
b: true, // isBuy
p: mids.BTC, // price
s: "0.001", // size
r: false, // reduceOnly
t: { limit: { tif: "Ioc" } },
}],
grouping: "na",
});
```
### Every call names its network
The first argument of every method is `"mainnet"` or `"testnet"`. There is no default and no
app-level setting, for the same reason [`ctx.evm`](/compose/context/evm/chains) makes you pass a
chain: a forgotten argument must be a type error, never a silent mainnet action.
### Field order is handled for you
A HyperCore action is hashed with its fields in a canonical order. Get that order wrong and the
signature recovers a different address, so the exchange rejects the action with a confusing
`User or API Wallet 0x... does not exist` error.
Compose canonicalizes every known action against Hyperliquid's own schemas before signing, so this
class of failure cannot reach the wire, including actions you build by hand and pass to
`exchange`. An action type Compose does not recognize (a brand new one, for example) is sent
through unchanged with a warning in your logs, and then field order is yours to get right.
### Namespaces
```typescript theme={"dark"}
hypercore: {
info(network, query, retryConfig?): Promise;
exchange(network, wallet, action, options?): Promise;
info.allMids / l2Book / outcomeMeta / outcomeTemplates / clearinghouseState
/ spotClearinghouseState / delegatorSummary / userFills
trade: order, cancel, cancelByCloid, modify, batchModify, twapOrder, twapCancel,
scheduleCancel, updateLeverage, updateIsolatedMargin, topUpIsolatedOnlyMargin
transfer: usdSend, spotSend, withdraw, usdClassTransfer, sendAsset, vaultTransfer,
subAccountTransfer, subAccountSpotTransfer
stake: deposit, withdraw, delegate
agent: approve, approveBuilderFee
outcome: activateDeployer, deactivateDeployer, deploy, deployQuestion, settle,
settleQuestion, tokenOperation
perpDeploy: registerAsset, setOracle, haltTrading, setFundingMultipliers,
setFundingInterestRates, setOpenInterestCaps, setSubDeployers, setFeeRecipient,
setMarginTableIds, setMarginModes, setDeployerFees, setPerpAnnotation, disableDex
account: createSubAccount, subAccountModify, createVault, vaultModify, vaultDistribute,
setDisplayName, setReferrer, registerReferrer, claimRewards, spotUser,
evmUserModify, reserveRequestWeight, borrowLend, setAbstraction, setPortfolioMargin
}
```
Every action method has the same shape:
```typescript theme={"dark"}
ns.method(network, wallet, params, options?): Promise
```
`params` matches Hyperliquid's action fields for that action. Method names follow Hyperliquid's
own names, except where those names are opaque: `stake.deposit` is `cDeposit`, `stake.withdraw`
is `cWithdraw`, `stake.delegate` is `tokenDelegate`, and `transfer.withdraw` is `withdraw3`. Each
method's doc comment records the raw action name so you can cross-reference the Hyperliquid docs.
### Options
```typescript theme={"dark"}
type HypercoreCallOptions = {
envelope?: {
vaultAddress?: Address; // act on behalf of a subaccount or vault
expiresAfter?: number; // reject the action after this ms timestamp
};
retryConfig?: RetryConfig;
};
```
`vaultAddress` is only valid for order-book style actions. Fund actions
(`transfer`, `stake`, `agent`) use Hyperliquid's user-signed scheme, which has no vault field, and
passing one throws.
### Reads
`info` is a plain read against Hyperliquid's info endpoint. The common queries have typed helpers,
and the generic form covers everything else:
```typescript theme={"dark"}
const mids = await ctx.hypercore.info.allMids("mainnet");
const state = await ctx.hypercore.info.clearinghouseState("mainnet", wallet.address);
// anything without a helper
const fills = await ctx.hypercore.info("mainnet", {
type: "userFillsByTime",
user: wallet.address,
startTime: since,
});
```
Reads are retried automatically. Actions are not: they are mutations, so they run once per task
attempt (see below).
### How actions are signed
Hyperliquid has two signing schemes and Compose picks the right one per action:
* **L1 actions** (orders, cancels, deployer actions) are msgpack-hashed and signed inside an
EIP-712 envelope.
* **User-signed actions** (transfers, staking, agent approval) are signed as per-action EIP-712
typed data.
Both work with either wallet type. A managed wallet signs on the Compose host. A wallet created
from a private key signs inside your task process, so the key never leaves it: Compose builds the
payload, your task signs it, and Compose submits the signed result.
### Retries and duplicate actions
Exchange actions are mutations: by default they are attempted once, and a task retry replays the
recorded result rather than sending a second action.
HyperCore nonces are single-use, which Compose leans on for the ambiguous case where an action was
submitted but the result never came back. A replay re-submits the identical signed action, the
exchange rejects the reused nonce, and Compose reports that as success:
```json theme={"dark"}
{ "status": "ok", "response": { "type": "duplicateNonce" } }
```
The action landed the first time. Read current state with `info` if you need the original response.
Nonces are timestamps and must fall within roughly two days of now. A run resumed after that
window fails with a stale-nonce error rather than silently re-executing an action that may
already have landed.
### Rate limits
Hyperliquid limits actions per address, roughly one action per 1 USDC of cumulative traded volume,
after an initial allowance. Reads are limited per IP. An app that submits actions far faster than
it trades will eventually be throttled by the exchange; see Hyperliquid's
[rate limit documentation](https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/rate-limits-and-user-limits).
### HIP-3: builder-deployed perp markets
`perpDeploy` operates a perp DEX you have deployed. The deployer supplies the oracle, and
Hyperliquid expects a price roughly every three seconds:
```typescript theme={"dark"}
await ctx.hypercore.perpDeploy.setOracle("mainnet", wallet, {
dex: "mydex",
oraclePxs: [["GOLD", "2650.5"]], // sorted by key
markPxs: [],
externalPerpPxs: [["GOLD", "2650.4"]], // sorted by key
});
```
A Compose task is a scheduled run, not a long-lived process. `setOracle` works for a periodic
push, but the fastest cron is once a minute, so Compose alone does not meet the three second
cadence HIP-3 expects of a production oracle. Treat this as a way to operate deployer actions,
not as a complete price-feed service.
All list-of-tuple parameters must be sorted by key before signing. Compose sorts the ones it
builds for you; when you pass tuples directly, sort them.
### HIP-4: outcome markets
`outcome` deploys and settles HIP-4 outcome markets. Markets are instantiated from templates that
validators have approved, so you fill in a template's keywords rather than defining an arbitrary
market:
```typescript theme={"dark"}
// what templates exist right now
const templates = await ctx.hypercore.info.outcomeTemplates("testnet");
await ctx.hypercore.outcome.deploy("testnet", wallet, {
templateId: "binaryPrice2",
keywordToValue: { perp: "BTC", threshold: "65000", time: "20260815-1800" },
});
```
Settlement must echo the market's canonical metadata exactly as `outcomeMeta` reports it, so store
it when you deploy:
```typescript theme={"dark"}
const meta = await ctx.hypercore.info.outcomeMeta("testnet");
const market = meta.outcomes.find((o) => o.outcome === outcomeIndex);
await ctx.hypercore.outcome.settle("testnet", wallet, {
outcome: market.outcome,
settleFraction: priceAtExpiry > threshold ? "1" : "0",
nameAndDescription: [market.name, market.description],
sideNames: [market.sideSpecs[0].name, market.sideSpecs[1].name],
});
```
Outcome token side index `0` is the **Yes** side: it maps to `sideSpecs[0]`. Deploying and
settling outcomes requires an activated outcome deployer, which has a staking requirement, and
testnet caps how many outcomes a deployer can have open and deploy per day.
### Raw actions
Anything without a helper goes through `exchange`, which signs, canonicalizes, and submits any
action:
```typescript theme={"dark"}
await ctx.hypercore.exchange("mainnet", wallet, {
type: "scheduleCancel",
time: Date.now() + 60_000,
});
```
### Example
A complete app that runs a vault on HyperCore (deposits attributed from on-chain transfers, share
accounting in [collections](/compose/context/collections), a strategy leg trading a perp, and
conditional payouts) is in
[documentation-examples](https://github.com/goldsky-io/documentation-examples/tree/main/compose/hypercore-vault).
A second example,
[hip4-outcome-oracle](https://github.com/goldsky-io/documentation-examples/tree/main/compose/hip4-outcome-oracle),
deploys and settles recurring HIP-4 markets.
# Compose context overview
Source: https://docs.goldsky.com/compose/context/overview
How Compose context functions provide auditable, retryable, and durable access to the outside world from sandboxed tasks.
Context functions allow task sandboxes to access the outside world.
Context functions support individual retry configuration and are automatically logged for auditing and debugging. All communication outside of the task sandbox happens via Context Functions, so Compose apps run deterministically given the same world context.
## Retry Configuration
All Context functions accept an optional retry configuration:
```typescript theme={"dark"}
type ContextFunctionRetryConfig = {
max_attempts: number; // 3 for read-only calls, 1 for mutations
initial_interval_ms: number; // Default: 500
backoff_factor: number; // Default: 2
};
```
**How Context Function Retries Work:**
* Each context function call can have its own retry configuration
* If a context function fails, it retries according to its configuration
* If all context function retries are exhausted, the context function will throw
* If you don't catch a failed context function call, a task-level retry may trigger, restarting the task and any context-function retries
## Durable execution and context caching
Compose provides durable execution guarantees. All context function calls are deterministically cached: if a task is interrupted (e.g. by a restart or deployment) and resumed, context functions that already completed return their cached results instead of re-executing. This means:
* Transactions that already succeeded will not be re-sent
* Fetch calls that already returned will not be re-made
* Collection operations that already completed will not be repeated
This caching is scoped to each individual task run. Cached results are automatically cleaned up when the run completes (success or failure).
Non-deterministic values, such as timestamps or random IDs, must be produced through [ctx.sideEffect()](./side-effect) so a replay returns the same value instead of recomputing it.
By default, read-only context calls make up to 3 attempts (`max_attempts: 3`, `initial_interval_ms: 500`, `backoff_factor: 2`). This covers `readContract`, `simulate`, `getBalance`, and `ctx.fetch` with `GET`, `HEAD`, or `OPTIONS`. Mutations such as `callTask`, `writeContract`, `sendTransaction`, and `ctx.fetch` with `POST`, `PUT`, `PATCH`, or `DELETE` default to a single attempt (`max_attempts: 1`). Pass a `retryConfig` to override either default.
## Overview of key context properties and functions
Context covers the following. Use the left nav or links below to find full reference docs.
* State Management - [Collections](./collections)
* Blockchain Interactions - [evm](./evm/overview)
* HTTP requests - [fetch](./fetch)
* Task to task execution - [callTask](./call-task)
* Non-deterministic values - [sideEffect](./side-effect)
* Reading env variables - [env](./env)
* Reorg handling - [Reorgs](./evm/reorgs)
* Turbo pipeline management - [turbo](./turbo)
* Direct SQL access - [db](./db)
* Run-aware logging - [logger](#logger)
## Full TaskContext interface
```typescript theme={"dark"}
export type ContextFunctionRetryConfig = {
max_attempts: number;
initial_interval_ms: number;
backoff_factor: number;
};
export type Chain = {
id: number;
name: string;
testnet: boolean;
nativeCurrency: {
name: string;
symbol: string;
decimals: number;
};
rpcUrls: {
public: { http: string[] };
default: { http: string[] };
};
blockExplorers: {
default: { name: string; url: string };
};
contracts?: Record;
};
export type ScalarIndexType = "text" | "numeric" | "boolean" | "timestamptz";
export interface CollectionIndexSpec {
path: string;
type: ScalarIndexType;
unique?: boolean;
}
export interface FindOptions {
limit?: number;
offset?: number;
}
// Filter helpers for comparison operators
export type FilterHelper =
| "$gt"
| "$gte"
| "$lt"
| "$lte"
| "$in"
| "$ne"
| "$nin"
| "$exists";
export type HelperValue = Partial<
Record
>;
export type FilterValue = string | number | boolean | HelperValue;
export type Filter = Record;
export type WithId = T & { id: string };
export interface Collection {
readonly name: string;
insertOne(doc: TDoc, opts?: { id?: string }): Promise<{ id: string }>;
findOne(filter: Filter): Promise | null>;
findMany(filter: Filter, options?: FindOptions): Promise>>;
getById(id: string): Promise | null>;
/**
* @param opts.upsert - Defaults to true. Set to false to throw if document doesn't exist.
*/
setById(
id: string,
doc: TDoc,
opts?: { upsert?: boolean },
): Promise<{ id: string; upserted?: boolean; matched?: number }>;
deleteById(id: string): Promise<{ deletedCount: number }>;
drop(): Promise;
}
export type Address = `0x${string}`;
export interface WalletConfig {
name?: string; // defaults to "default"
privateKey?: string;
sponsorGas?: boolean; // defaults to true for Privy wallets, false for private key wallets
}
export interface WebhookWalletConfig {
url: string;
address: Address;
headers?: Record;
name?: string;
}
export type ReplayOnReorg = {
type: "replay";
};
export type LogOnReorg = {
type: "log";
logLevel?: "error" | "info" | "warn"; // defaults to "error"
};
export type CustomReorgAction = {
type: "task";
// your task will be sent with a payload the full transaction minus gas and nonce
task: string;
};
export type OnReorgOptions = ReplayOnReorg | LogOnReorg | CustomReorgAction;
export type OnReorgConfig = {
action: OnReorgOptions;
depth: number;
};
export interface TransactionConfirmation {
// this the number of block confirmations before we resolve the promise
// i.e. "wait 5 blocks before proceeding to the next step in my task"
confirmations?: number;
onReorg?: OnReorgConfig;
}
export interface IWallet {
readonly name: string;
readonly address: Address;
writeContract(
chain: Chain,
contractAddress: Address,
functionSig: string,
args: unknown[],
confirmation?: TransactionConfirmation,
retryConfig?: ContextFunctionRetryConfig,
): Promise<{
hash: string;
receipt: TransactionReceipt;
userOpHash?: string; // set for gas-sponsored transactions (ERC-4337)
}>;
readContract(
chain: Chain,
contractAddress: Address,
functionSig: string,
args: unknown[],
retryConfig?: ContextFunctionRetryConfig,
): Promise;
sendTransaction(
config: {
to: Address;
data: `0x${string}`;
chain: Chain;
value?: bigint;
maxFeePerGas?: bigint;
maxPriorityFeePerGas?: bigint;
gas?: bigint;
nonce?: number; // EOA wallets only
},
confirmation?: TransactionConfirmation,
retryConfig?: ContextFunctionRetryConfig,
): Promise<{
hash: string;
receipt: TransactionReceipt;
userOpHash?: string; // set for gas-sponsored transactions (ERC-4337)
}>;
simulate(
chain: Chain,
contractAddress: Address,
functionSig: string,
args: unknown[],
retryConfig?: ContextFunctionRetryConfig,
): Promise<{ hash: string }>;
getBalance(
chain: Chain,
retryConfig?: ContextFunctionRetryConfig,
): Promise; // native token balance in wei
}
export interface Log {
address: Address;
topics: `0x${string}`[];
data: `0x${string}`;
blockHash: `0x${string}`;
blockNumber: bigint;
logIndex: number;
transactionHash: `0x${string}`;
transactionIndex: number;
removed?: boolean;
}
export interface TransactionReceipt {
blockHash: `0x${string}`;
blockNumber: bigint;
contractAddress: Address | null;
cumulativeGasUsed: bigint;
effectiveGasPrice: bigint;
from: Address;
gasUsed: bigint;
logs: Log[];
logsBloom: `0x${string}`;
status: "success" | "reverted";
to: Address | null;
transactionHash: `0x${string}`;
transactionIndex: number;
type: "legacy" | "eip1559" | "eip2930" | "eip4844" | "eip7702";
}
export interface OnchainEvent {
blockNumber: number;
blockHash: string;
transactionIndex: number;
removed: boolean;
address: string;
data: `0x${string}`;
topics: `0x${string}`[];
transactionHash: string;
logIndex: number;
}
export interface FetchConfig {
method?: string;
headers?: Record;
body?: Record | string;
}
export interface Logger {
info(message: string, data?: Record): void;
warn(message: string, data?: Record): void;
error(message: string, data?: Record): void;
}
export type TaskContext = {
env: Record;
logger: Logger;
callTask: , T = unknown>(
taskName: string,
args: Args,
retryConfig?: ContextFunctionRetryConfig,
) => Promise;
sideEffect: (fn: () => T | Promise) => Promise;
fetch: (
url: string,
fetchConfigOrRetryConfig?: FetchConfig | ContextFunctionRetryConfig,
retryConfig?: ContextFunctionRetryConfig,
) => Promise;
evm: {
chains: Record;
wallet: (config: WalletConfig) => Promise;
webhookWallet: (config: WebhookWalletConfig) => Promise;
decodeEventLog: (abi: Abi, log: OnchainEvent) => Promise;
contracts: Record; // auto-generated from ABIs in src/contracts/
};
collection: (
name: string,
indexes?: CollectionIndexSpec[],
) => Promise>;
turbo: {
createPipeline: (config: CreateTurboPipelineConfig, retryConfig?: ContextFunctionRetryConfig) => Promise;
createJob: (config: CreateTurboJobConfig, retryConfig?: ContextFunctionRetryConfig) => Promise;
getPipeline: (name: string, retryConfig?: ContextFunctionRetryConfig) => Promise;
getStatus: (name: string, retryConfig?: ContextFunctionRetryConfig) => Promise;
listPipelines: (retryConfig?: ContextFunctionRetryConfig) => Promise;
pausePipeline: (name: string, retryConfig?: ContextFunctionRetryConfig) => Promise;
resumePipeline: (name: string, retryConfig?: ContextFunctionRetryConfig) => Promise;
restartPipeline: (name: string, options?: RestartOptions, retryConfig?: ContextFunctionRetryConfig) => Promise;
deletePipeline: (name: string, retryConfig?: ContextFunctionRetryConfig) => Promise;
getLogs: (name: string, options?: GetLogsOptions, retryConfig?: ContextFunctionRetryConfig) => Promise;
getState: (name: string, retryConfig?: ContextFunctionRetryConfig) => Promise;
validate: (definition: TurboPipelineDefinition, retryConfig?: ContextFunctionRetryConfig) => Promise;
};
db: {
query: >(
schema: string,
sql: string,
params?: (string | number | boolean | null)[],
retryConfig?: ContextFunctionRetryConfig,
) => Promise>;
};
};
```
See the [turbo reference](./turbo) for the full type definitions used above (`TurboPipeline`, `TurboPipelineStatus`, `ValidateResult`, etc.), and the [db reference](./db) for `DbQueryResult`.
## Logger
`context.logger` is a run-aware structured logger. Unlike `console.log`, logs from `context.logger` carry the task name and run ID, so in the dashboard you can:
1. **Search app-level logs, then jump to the run.** On the Logs tab of your app, you can search for a log pattern across all runs. Each matching log entry includes a "View run" link that takes you directly to the full task run, where you can see the complete OpenTelemetry trace of everything that happened in that run.
2. **View run-specific logs.** On any task run's detail page, the Logs tab shows only logs from that specific run, so you see what happened in a single execution.
### Usage
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ logger, evm, env }: TaskContext) {
logger.info("Starting price update", { source: "coingecko" });
try {
const wallet = await evm.wallet();
const { hash } = await wallet.writeContract(
evm.chains.base,
env.CONTRACT_ADDRESS as `0x${string}`,
"setPrice(bytes32,bytes32)",
[timestampBytes, priceBytes]
);
logger.info("Price updated", { hash, chain: "base" });
} catch (error) {
logger.error("Price update failed", {
error: error instanceof Error ? error.message : String(error),
});
throw error;
}
}
```
### API
```typescript theme={"dark"}
interface Logger {
info(message: string, data?: Record): void;
warn(message: string, data?: Record): void;
error(message: string, data?: Record): void;
}
```
Each method takes a message string and an optional `data` object for structured metadata. BigInt values (common in EVM code) are automatically serialized as strings.
### `console.log` vs `context.logger`
Both `console.log` and `context.logger` output to your terminal during local development. The difference is in the cloud:
| | `console.log` | `context.logger` |
| - | - | - |
| Appears in app-level logs | Yes | Yes |
| Tagged with run ID and task name | No | Yes |
| "View run" link in dashboard | No | Yes |
| Appears in run-specific Logs tab | No | Yes |
| Structured `data` field | No | Yes |
Use `console.log` for quick debugging. Use `context.logger` when you want logs that you can trace back to a specific task run in production.
## Next Steps
Make auditable HTTP requests with fetch.
Manage state across tasks and task runs with collections.
# Non-Deterministic Values (sideEffect)
Source: https://docs.goldsky.com/compose/context/side-effect
Cache non-deterministic values like timestamps and UUIDs with ctx.sideEffect so task replays stay deterministic.
## Non-deterministic values and durable execution
Durable execution replays a task from the start after an interruption, such as a restart or rolling deploy. Context calls that already completed return their cached results instead of re-running. A bare `Date.now()` or `crypto.randomUUID()` is not a context call, so it produces a different value on every replay and desynchronizes the run from its cached history.
`ctx.sideEffect()` runs your callback once and caches the returned value like any other context call. On replay, it returns the cached value and the callback does not run again.
```typescript theme={"dark"}
sideEffect(fn: () => T | Promise): Promise
```
### Example
Generate a request id and timestamp once, then reuse them in a `writeContract` call:
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main(ctx: TaskContext) {
// Computed once; the cached values are returned on any replay.
const { requestId, timestamp } = await ctx.sideEffect(async () => ({
requestId: crypto.randomUUID(),
timestamp: Date.now(),
}));
const wallet = await ctx.evm.wallet({ name: "default" });
// requestId and timestamp are passed in the contract call args
await wallet.writeContract(
ctx.evm.chains.base,
ctx.env.CONTRACT_ADDRESS as `0x${string}`,
"recordRequest(string,uint256)",
[requestId, timestamp]
);
}
```
Use `ctx.sideEffect()` for any value that must stay the same across replays: timestamps, random values, UUIDs, or any other source of non-determinism.
For the caching model that makes this necessary, see [Durable execution and context caching](./overview#durable-execution-and-context-caching).
## Next Steps
Invoke another task in the same app.
How context functions, caching, and retries work.
# Turbo Pipelines (turbo)
Source: https://docs.goldsky.com/compose/context/turbo
## Manage Turbo Pipelines with "turbo"
`ctx.turbo` lets a task create and manage [Turbo pipelines](/turbo-pipelines/introduction) and
[jobs](/turbo-pipelines/job-mode) from inside your Compose app. Use it to spin up a pipeline in
response to an on-chain event, kick off a one-time backfill and poll it to completion, or pause and
clean up pipelines your app owns.
A Turbo **job** is a pipeline whose definition has `job: true`: it runs to completion and then exits,
rather than streaming forever. `ctx.turbo.createJob` is a shortcut for `createPipeline` with that flag
set.
### How pipelines are named and cleaned up
Pipelines you create through `ctx.turbo` are namespaced under your Compose app. You pass a plain name
like `token-transfers`, and the pipeline is registered internally with your app's prefix. Every method
handles the prefix for you, so you always refer to pipelines by the plain name you gave them, and
`listPipelines` only returns pipelines that belong to your app.
When your Compose app is deleted, the pipelines it created are deleted with it, so you
don't have to track and tear them down yourself.
The namespaced name (app prefix included) has a length limit. If your app name plus the pipeline
name is too long, `createPipeline` throws. Keep pipeline names short and the error message tells you
the maximum.
### Methods
```typescript theme={"dark"}
turbo: {
createPipeline(config: CreateTurboPipelineConfig, retryConfig?): Promise;
createJob(config: CreateTurboJobConfig, retryConfig?): Promise;
getPipeline(name: string, retryConfig?): Promise;
getStatus(name: string, retryConfig?): Promise;
listPipelines(retryConfig?): Promise;
pausePipeline(name: string, retryConfig?): Promise;
resumePipeline(name: string, retryConfig?): Promise;
restartPipeline(name: string, options?: RestartOptions, retryConfig?): Promise;
deletePipeline(name: string, retryConfig?): Promise;
getLogs(name: string, options?: GetLogsOptions, retryConfig?): Promise;
getState(name: string, retryConfig?): Promise;
validate(definition: TurboPipelineDefinition, retryConfig?): Promise;
}
```
### Config types
```typescript theme={"dark"}
export type TurboPipelineDefinition = {
sources: Record;
transforms: Record;
sinks: Record;
job?: boolean;
};
export type CreateTurboPipelineConfig = {
name: string; // lowercase letters, numbers, and hyphens
resourceSize?: string;
description?: string;
useDedicatedIp?: boolean;
definition: TurboPipelineDefinition;
};
// createJob takes the same config — the client sets job: true for you.
export type CreateTurboJobConfig = Omit & {
definition: Omit;
};
export type RestartOptions = { clearState?: boolean };
export type GetLogsOptions = {
logLevels?: string; // comma-separated, e.g. "error,warn"
cursor?: number;
after?: number;
search?: string;
direction?: "asc" | "desc";
};
```
### Response types
```typescript theme={"dark"}
export type TurboPipeline = {
name: string;
status?: string;
version?: number;
definition?: TurboPipelineDefinition & {
name?: string;
resource_size?: string;
description?: string;
use_dedicated_ip?: boolean;
};
created_at: string;
updated_at?: string;
};
export type TurboPipelineStatus = {
name: string;
status: string;
};
export type ValidateResult = {
valid: boolean;
errors?: Array<{ message: string } | string>;
warnings?: Array<{ message: string } | string>;
};
export type PipelineActionResult = {
name: string;
action: string;
};
export type PipelineDeleteResult = {
name: string;
deleted: boolean;
};
export type PipelineLogsResult = {
logs: unknown[];
};
```
The `definition` is the same [pipeline configuration](/turbo-pipelines/pipeline-config) you'd write in
YAML, expressed as an object. Reads (`getPipeline`, `getStatus`, `listPipelines`, `getLogs`,
`getState`, `validate`) retry on transient failures by default; the mutating methods do not. Every call
is recorded as a span on the task run, like [`ctx.fetch`](./fetch).
### Examples
#### Kick off a one-time backfill (job)
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ turbo }: TaskContext) {
const job = await turbo.createJob({
name: "solana-backfill",
resourceSize: "m",
definition: {
sources: {
token_transfers: {
type: "dataset",
dataset_name: "solana.token_transfers",
version: "1.0.0",
start_block: 250000000,
end_block: 250000002,
},
},
transforms: {
filtered: { type: "sql", primary_key: "id", sql: "SELECT * FROM token_transfers" },
},
sinks: {
out: { type: "postgres", from: "filtered", schema: "public", table: "token_transfers", secret_name: "MY_PG", primary_key: "id" },
},
},
});
return job;
}
```
#### Create a streaming pipeline in response to an event
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ turbo }: TaskContext, params: { contract: string }) {
// Sanitize the contract address for use in the pipeline name
const slug = params.contract.slice(2, 10).toLowerCase();
return turbo.createPipeline({
name: `transfers-${slug}`,
definition: {
sources: {
logs: { type: "dataset", dataset_name: "ethereum.raw_logs", version: "1.0.0", start_at: "latest" },
},
transforms: {
filtered: {
type: "sql",
primary_key: "id",
sql: `SELECT * FROM logs WHERE address = lower('${params.contract}')`,
},
},
sinks: {
out: { type: "postgres", from: "filtered", schema: "public", table: "transfers", secret_name: "MY_PG", primary_key: "id" },
},
},
});
}
```
#### Poll a job until it finishes
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ turbo }: TaskContext) {
const { status } = await turbo.getStatus("solana-backfill");
if (status === "STOPPED" || status === "FAILED") {
const logs = await turbo.getLogs("solana-backfill", { logLevels: "error" });
return { done: true, status, logs };
}
return { done: false, status };
}
```
Pair this with a [cron trigger](../task-triggers) to check on a long-running job on a schedule
instead of blocking a single task run.
#### Validate before deploying
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ turbo }: TaskContext) {
const result = await turbo.validate({
sources: { blocks: { type: "dataset", dataset_name: "ethereum.raw_blocks", version: "1.0.0" } },
transforms: { t: { type: "sql", primary_key: "id", sql: "SELECT * FROM blocks" } },
sinks: { out: { type: "blackhole", from: "t" } },
});
if (!result.valid) {
const messages = (result.errors ?? []).map((e) =>
typeof e === "string" ? e : e.message
);
throw new Error(messages.join("; "));
}
}
```
#### List, pause, and delete the pipelines your app owns
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ turbo }: TaskContext) {
const pipelines = await turbo.listPipelines();
for (const p of pipelines) {
await turbo.pausePipeline(p.name);
}
await turbo.deletePipeline("solana-backfill");
}
```
## Next Steps
Learn how Turbo pipelines, sources, transforms, and sinks work.
Run a pipeline as a one-time job that exits when it's done.
# Debugging
Source: https://docs.goldsky.com/compose/debugging
Debug Compose apps locally with chain forking, wallet impersonation, and per-task callTask invocation.
## Debugging locally
Logs and run events stream to the terminal where you run `goldsky compose start`. Output is formatted and colored so it's easy to scan.
### Chain forking
For testing against live on-chain state without spending gas, start your app with the `--fork-chains` flag:
```bash theme={"dark"}
goldsky compose start --fork-chains
```
This creates in-memory forks of all chains you interact with, powered by [TEVM](https://tevm.sh). All wallets are automatically funded with test ETH, so you can freely test contract interactions. Your task code stays exactly the same as in production; no special dev code needed. See [Environments](./environments#forking-for-local-compose-development) for more details.
#### Impersonating wallet addresses
If you need to test privileged contract methods that are restricted to a specific address (e.g. an owner or admin), you can impersonate that address on the fork without needing the private key:
```bash theme={"dark"}
goldsky compose start --fork-chains --impersonate "my-wallet=0xOwnerAddress"
```
Any wallet whose name matches the mapping will resolve to the impersonated address and all contract interactions will execute as that address on the local fork. Your task code doesn't change at all. See [Impersonated wallets](./context/evm/wallets#impersonated-wallets) for full details.
### Testing individual tasks
`callTask` targets your deployed app by default. To test a task against your locally running app, pass `--env local`:
```bash theme={"dark"}
goldsky compose callTask my_task '{"key": "value"}' --env local
```
The payload must be valid JSON. The local port is resolved automatically (the `--port` flag, then `.compose/.port`, then 4000), so this works even when `start` picked a fallback port.
## Debugging a Deployed Compose App
Once your app is running in the cloud, debug it from its details page in the web app at `https://app.goldsky.com/dashboard/compose/{appName}`. From there you can view logs and inspect task run records. See [Monitoring your app via the webapp](./deploy-monitor#monitoring-your-app-via-the-webapp) for a walkthrough.
Every context function call (for example `evm.wallet()`, `evm.writeContract(...)`, `ctx.db.collection(...)`) is automatically captured as a run event and shown in the task run view.
### Using `context.logger` for run-aware logs
Use `context.logger` instead of `console.log` to get logs tagged with the task name and run ID. In the dashboard you can then:
1. **Search for a log pattern** in the app-level Logs tab (e.g. search for "payout failed")
2. **Click "View run"** on any matching log entry to jump directly to that task run
3. **Inspect the full trace**: every context function call, other logs, and the outcome of that specific run
Logs emitted with `context.logger` also appear in the **run-specific Logs tab**, so when you're looking at a single task run you see only the logs from that execution. See the full [logger reference](./context/overview#logger) for the API.
### Examples
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main(
{ evm, logger }: TaskContext,
params: { payouts: bigint[]; resultId: string }
) {
try {
const { payouts, resultId } = params;
logger.info("Reporting payouts", { resultId, payoutCount: payouts.length });
const wallet = await evm.wallet();
const { hash } = await wallet.writeContract(
evm.chains.polygon,
"0x1234567890abcdef1234567890abcdef12345678" as `0x${string}`,
"reportPayouts(bytes32,uint256[])",
[resultId, payouts]
);
logger.info("Payouts reported", { hash });
return { hash };
} catch (error) {
if (error instanceof Error && error.message.includes("payout denominator already set")) {
logger.warn("Payout denominator already set, marking as resolved", { resultId });
} else {
logger.error("Error reporting payout", {
error: error instanceof Error ? error.message : String(error),
});
throw error;
}
}
}
```
## Next Steps
Learn about deploying your app to the cloud for production use cases.
View the full CLI command reference
# Deploying and Monitoring
Source: https://docs.goldsky.com/compose/deploy-monitor
Deploy Compose apps with goldsky compose deploy and monitor runs, logs, and state through the Goldsky webapp.
Once you've built your Compose App and tested it locally, deploy it. Your app runs in an isolated runtime environment
with a dedicated database. Environment variables and secrets you've provided are available to your app, and the durability engine resumes task execution
across restarts and rolling deploys. You can monitor your app via the Goldsky webapp.
### The `deploy` command
Deploy by running this command with a reference to your manifest file. The command is idempotent: it upserts your app to the cloud.
```bash theme={"dark"}
goldsky compose deploy
```
Your manifest must include an `api_version` field to deploy. This pins your app to a specific Compose runtime. Use `"stable"` if unsure. See [Release channels](./app-configuration#release-channels) for details.
The Compose CLI extension provisions the necessary resources and launches your app based on your manifest. Once complete, cron tasks start and HTTP triggers become available. See [Task triggers](./task-triggers) for more information.
On success, `deploy` prints the URL of your app's dashboard.
### Hosted Postgres database
When you deploy, Compose automatically provisions a dedicated Postgres database for your app. This database is used for two things:
* **Your state.** Any [collections](./context/collections) you create in your tasks are stored here. You can query or inspect your own data directly.
* **Compose internal state.** Compose uses the same database to power durable execution (resuming tasks cleanly after crashes and rolling deploys), reorg monitoring for transactions, and wallet bookkeeping. These internal tables live in reserved namespaces and are managed by the runtime.
Because your app has its own database, your data is isolated from other apps and from Goldsky's own systems.
### Monitoring your app via the webapp
Like with our indexing products, you'll see your Compose Apps in the Goldsky webapp. From there you can view the app's status, recent task runs (with per-operation details: each `ctx.*` call a task made), and raw log output.
The URL for your app's dashboard is:
```
https://app.goldsky.com/{projectId}/dashboard/compose/{appName}
```
#### Viewing and downloading deployed source
When you deploy, the CLI uploads your app's full local source tree: the transitive local import closure, `package.json` and lockfile, `tsconfig.json`, and everything under `src/contracts/`. `node_modules`, `.env*`, and files that look like keys or secrets are excluded.
The dashboard's Code tab is a file browser over that source tree. The Download app button produces a zip that is a runnable local Compose project, including a names-only `.env.example`.
Apps deployed before source capture existed show per-task compiled bundles instead of original sources. Redeploy with a current CLI to get full fidelity. Very large projects may skip source capture, in which case the CLI warns at deploy time and the dashboard falls back to the same per-task bundles.
The CLI equivalents are [`goldsky compose source`](./cli-reference#inspecting-a-deployed-app) and [`goldsky compose download`](./cli-reference#inspecting-a-deployed-app); see [App lifecycle](./app-lifecycle#view-and-download-deployed-source) for the workflow.
### Managing a deployed app from the CLI
For day-to-day app management from the terminal, use the [lifecycle commands](./app-lifecycle):
```bash theme={"dark"}
goldsky compose status # runtime status
goldsky compose list # all apps in your project
goldsky compose logs -f # tail logs
goldsky compose pause # stop triggers without deleting state
goldsky compose resume
goldsky compose delete # delete the app (and optionally the database)
```
### Deleting a Compose app
You can delete a Compose app either from the webapp (navigate to the app's dashboard and click **Delete**) or from the CLI:
```bash theme={"dark"}
goldsky compose delete
```
Both paths require you to type the app name to confirm. See [App lifecycle](./app-lifecycle#delete-an-app) for CLI flags.
#### Database management options
When deleting a Compose app that uses a hosted Postgres database, you can choose whether to keep or delete the associated database:
* **Delete associated database**: The hosted Postgres database will be permanently deleted along with the app and all its data. This is the default in the webapp modal ("Delete associated database" is pre-checked). From the CLI, pass `--delete-database` or answer the interactive prompt to opt in.
* **Keep database**: Preserve the database when deleting the app. This is useful if you want to retain your data for analysis or migrate it to another app. This is the default in the CLI; in the webapp, uncheck "Delete associated database" before confirming.
Database deletion is permanent and cannot be undone. Make sure to back up any important data before deleting.
#### Pipeline validation
If you choose to delete the associated database, Compose checks whether any active pipelines use it. If one or more pipelines reference the database, deletion is blocked and the error message lists the affected pipelines.
To proceed with database deletion in this case, you must first:
1. Delete or modify the pipelines that reference the database
2. Then retry deleting the Compose app with the database option selected
Alternatively, uncheck the "Delete associated database" option: the app is deleted but the database stays available to the existing pipelines.
# Environments and RPCs
Source: https://docs.goldsky.com/compose/environments
Configure Compose for local chains, forked networks, testnets, and mainnets across the development lifecycle.
We covered how to set your own [Environment Variables](./app-configuration#env-variables) in the manifest, but you'll likely need to work with smart
contracts locally and on testnets. Additionally you'll likely need to interact with APIs, both your own and third party ones, with different credentials
and different URLs throughout the development lifecycle.
Compose supports two manifest environments: `local` (used when you run `goldsky compose start` or `goldsky compose dev`) and `cloud` (used when your app
runs on Compose's infrastructure after `goldsky compose deploy`). The active environment is picked automatically based on whether the runtime is executing
locally or in the cloud. There is no `--env` flag on `deploy`.
## Chains and RPCs
Compose supports four chain environments: fully local (Foundry, Truffle, Hardhat, etc), locally forked networks (powered by TEVM),
testnets and mainnets.
### Local chains (Foundry, Truffle, Hardhat)
If you're developing your compose app locally alongside a smart contract running on a local chain, you can customize the RPC endpoints that Compose uses to read from
and write to your contract. You can use hard coded values right in the code, or env variables configured in your [Manifest](./app-configuration#env-variables).
#### Use a local RPC node in code
If you're just starting out your contract with local development, and building your Compose app at the same time, you can use a Custom chain object right in code.
For full reference in custom chain configuration, go [here](./context/evm/chains). For full reference on interacting with contracts, go [here](./context/evm/contracts).
```typescript theme={"dark"}
import { TaskContext, Chain } from "compose";
export async function main({ evm }: TaskContext) {
// This is a local-only private key I've funded on my test chain (thus safe to hard code)
// For private keys used on mainnets and testnets, always use Secrets
const privateKey = "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
const wallet = await evm.wallet({ privateKey });
const localChain: Chain = {
id: 0,
name: "foundry-local",
testnet: true,
nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
rpcUrls: {
default: { http: ["http://127.0.0.1:8545"] }, // this is the url used by your local Anvil (etc) node
public: { http: ["http://127.0.0.1:8545"] },
},
blockExplorers: {
default: { name: "na", url: "http://127.0.0.1:8545" }, // not used for local dev, so you can pass in any value here
},
};
const localContractAddress = "0x1234567890abcdef1234567890abcdef12345678" as `0x${string}`;
const resultId = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
const payouts = [1000n, 2000n, 3000n];
const { hash } = await wallet.writeContract(
localChain,
localContractAddress,
"reportPayouts(bytes32,uint256[])",
[resultId, payouts],
{
confirmations: 3,
}
);
}
```
#### Use a local RPC only in the dev environment
If you already have your contract and compose app deployed but are iterating on the contract and the Compose App locally, you can use env variables
to override the RPC only when running locally.
### Manifest
```yaml theme={"dark"}
name: "my_app"
env: # since we're only specifying a local version of the RPC_URL env var, it'll be undefined when deployed to cloud
local:
# This is a local-only private key I've funded on my test chain (thus safe to hard code)
# For private keys used on mainnets and testnets, always use Secrets
PRIVATE_KEY: "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
RPC_URL: "http://127.0.0.1:8545"
CONTRACT_ADDRESS: "0x67206e6E82FA1b11fd8C545Ad3422dBb1444E53C" # we can update this as we iterate on the contract locally
cloud:
CONTRACT_ADDRESS: "0x1234567890abcdef1234567890abcdef12345678" # we can update this when we deploy our contract to mainnet
tasks:
- name: "bitcoin_oracle"
path: "./src/tasks/bitcoin_oracle.ts"
triggers:
- type: "cron"
expression: "* * * * *"
```
Task code
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
// private key will be undefined in cloud (since env var isn't set for cloud) and the wallet will default to our auto-funded smart wallets
// however you can use a mainnet private key if you want by saving it as a secret, see wallet docs for more info
const wallet = await evm.wallet({ privateKey: env.PRIVATE_KEY });
const chain = {
...evm.chains.base,
};
// override the chain's RPC only if the env var is set
if (env.RPC_URL) {
chain.rpcUrls = {
default: { http: [env.RPC_URL] }, // this is the url used by your local Anvil (etc) node
public: { http: [env.RPC_URL] },
};
}
const resultId = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
const payouts = [1000n, 2000n, 3000n];
const { hash } = await wallet.writeContract(
chain,
env.CONTRACT_ADDRESS as `0x${string}`, // use the env var for the contract address which we'll update as we iterate
"reportPayouts(bytes32,uint256[])",
[resultId, payouts],
{
confirmations: 3,
}
);
}
```
### Forking for local Compose development
If you're just iterating on your Compose app but your smart contract isn't changing, then a good option for local development can be to use TEVM for forking.
This is done by starting your app with the `--fork-chains` option like so: `goldsky compose start --fork-chains`. When you use forking, everything in your code will be exactly
the same locally as in cloud, but internally we'll fork all the chains you interact with and we'll fund all your wallets on the local fork for gas. You can
iterate on your compose app freely while testing against a cloned contract and its state.
You can also impersonate specific wallet addresses on the fork to test privileged contract methods without needing the private key. See [Impersonated wallets](./context/evm/wallets#impersonated-wallets) for details.
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm }: TaskContext) {
// we'll auto-fund all smart wallets in forking mode so you can simulate gas sponsoring in prod
const wallet = await evm.wallet({ name: "my-smart-wallet" });
const resultId = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
const payouts = [1000n, 2000n, 3000n];
const { hash } = await wallet.writeContract(
// when you run compose with the --fork-chains flag we'll make a fork of base at the time of running the app and we'll clone all your existing contract state
// when you deploy this to cloud, it'll run against the actual base mainnet, thus you don't need any special dev code when testing locally with forking
evm.chains.base,
"0xabcdefabcdefabcdefabcdefabcdefabcdefabcd" as `0x${string}`,
"reportPayouts(bytes32,uint256[])",
[resultId, payouts],
{
confirmations: 3,
}
);
}
```
### BYO RPCs for mainnets and testnets
By default, Compose uses our internal [edge RPCs](https://erpc.cloud/edge) and our gas-sponsored [smart wallets](./context/evm/wallets), so you don't need to manage wallets,
RPCs, or gas funding. If you'd rather use your own RPC nodes or wallets, that's supported too. Below is an example of using your own RPCs and private keys. See [Wallets](./context/evm/wallets) and [Chains](./context/evm/chains)
for more details.
### Manifest
```yaml theme={"dark"}
name: "my_app"
secrets:
# set these with "goldsky compose secret set --value " prior to deploying, see secrets docs for more info
- PROD_FUNDING_WALLET
- ALCHEMY_TOKEN
env:
local:
ALCHEMY_BASEURL: "https://base-testnet.g.alchemy.com/v2/"
cloud:
ALCHEMY_BASEURL: "https://base-mainnet.g.alchemy.com/v2/"
tasks:
- name: "bitcoin_oracle"
path: "./src/tasks/bitcoin_oracle.ts"
triggers:
- type: "cron"
expression: "* * * * *"
```
Task code
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ evm, env }: TaskContext) {
// env.PROD_FUNDING_WALLET was populated via the secrets reference in the manifest
const wallet = await evm.wallet({ privateKey: env.PROD_FUNDING_WALLET });
const chain = {
...evm.chains.base,
rpcUrls: {
default: { http: [`${env.ALCHEMY_BASEURL}${env.ALCHEMY_TOKEN}`] },
public: { http: [`${env.ALCHEMY_BASEURL}${env.ALCHEMY_TOKEN}`] },
},
};
const resultId = "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
const payouts = [1000n, 2000n, 3000n];
const { hash } = await wallet.writeContract(
chain,
"0x1234567890abcdef1234567890abcdef12345678" as `0x${string}`,
"reportPayouts(bytes32,uint256[])",
[resultId, payouts],
{
confirmations: 3,
}
);
}
```
## Other environment use cases
Another common need for different environments is interacting with your own, or third party, APIs. For example, you may need to test your compose app
against a locally running version of your API for local development. Configure this with env vars in your [Manifest](./app-configuration#env-variables).
### Manifest
```yaml theme={"dark"}
name: "my_app"
env:
local:
API_BASE: "http://localhost:4001"
cloud:
API_BASE: "https://api.mydomain.com"
tasks:
- name: "bitcoin_oracle"
path: "./src/tasks/bitcoin_oracle.ts"
triggers:
- type: "cron"
expression: "* * * * *"
```
Task code
```typescript theme={"dark"}
import { TaskContext } from "compose";
export async function main({ env, fetch }: TaskContext) {
const apiEndpoint = `${env.API_BASE}/some/endpoint`;
const resp = await fetch(apiEndpoint);
}
```
# Migrate from Gelato W3F
Source: https://docs.goldsky.com/compose/gelato
Migrate from Gelato Web3 Functions to Compose, including triggers, task authoring, wallets, and monitoring.
Compose and Gelato Web3 Functions (W3F) have a lot of similarities and solve similar problems, but they work a bit differently. For the most part, anything you've done with W3F can be done in a similar fashion with Compose, but there are some differences to be aware of.
## Terminology
A few naming differences to keep in mind:
* Task: In Compose a "task" is a TypeScript file with your code logic. It can import from other files and libraries and must export a single `main` function. This is effectively the equivalent of a "function" in W3F terms.
* Trigger: In Compose a "trigger" encompasses the concept of both "triggers" and "tasks" in W3F.
## Configuration
Compose apps are completely configured within your code repository. All configuration is done in the [manifest](./app-configuration) YAML file (`compose.yaml`). Compose apps are deployed with the CLI, and the manifest is responsible for provisioning infra and dependencies.
## Triggers
Compose has similar triggering options to W3F with a few differences:
* Compose doesn't differentiate between cron and time intervals: it just uses cron expressions for time-based triggering.
* Compose has HTTP triggers, so your application logic can trigger tasks and send payloads over HTTP with optional bearer token authentication.
* Like W3F, Compose tasks can be triggered by onchain events. You declare them directly in your manifest with an `onchain_event` trigger (network, contract address, event signatures), with no separate pipeline to configure. See [Task triggers](./task-triggers#chain-event-triggers).
* For more complex event-driven flows than a single contract's events can express, you can build a Turbo pipeline with a webhook sink pointed at a Compose HTTP trigger.
* Compose doesn't support per-block triggers out of the box. You can recreate this with a Turbo pipeline (webhook sink) that indexes every block and posts to an HTTP-triggered task.
## Task authoring and output
All task authoring is done in TypeScript for Compose apps. We do not currently support authoring tasks in Solidity like W3F. Unlike W3F, Compose tasks don't output onchain transactions by default. They can return a JSON payload when called through an HTTP trigger, but all other effects are done inside the task code. Tasks can execute any number of onchain transactions, make HTTP calls to external systems, store data in collections for use later or by other tasks, and so on. Since external interactions happen in code rather than as task output, Compose apps can include any number of them.
## Monitoring
Both platforms have a web UI dashboard for monitoring, logs, and so on. Compose also has an event log that gives details about task execution steps and failures. This is useful for both auditing and debugging the behavior of Compose apps. The event log is built to be publicly shareable as an audit trail, but currently it's only visible to users logged into a Goldsky project at app.goldsky.com.
Compose does not currently have a notification system for app errors beyond proactively checking the UI and our own internal monitoring and on-call rotation for platform issues. However, logging can be set up within Compose apps to send to external systems. Compose doesn't make assumptions about what constitutes a failure within a task run, so you define success/failure conditions yourself and wire up logging to existing systems. We are designing a system for task logic to define its own critical failure conditions, which would let us use our existing email notification system and flag Compose apps with critical failures in the dashboard. If this is a strict requirement, please contact us with your specific requirements.
## Wallets, gas, and compute funding
Gas funding in Goldsky doesn't rely on users depositing gas tokens in our system. Instead, transactions are sent from wallets created in code, and any number of wallets can be created within your Compose app. By default, wallets are Privy-managed smart wallets with built-in gas sponsorship enabled: gas is metered as you use it and paid for as part of your monthly Goldsky bill. Compose also lets you store your own EOA private keys as secrets and use those to create wallets. EOA wallets default to paying their own gas (so you must keep them funded), but you can opt into gas sponsorship per wallet by passing `sponsorGas: true` to `evm.wallet({...})` (see the [wallets reference](./context/evm/wallets)). Compute costs are included in your monthly Goldsky bill, paid in fiat.
# Build a Bitcoin price oracle
Source: https://docs.goldsky.com/compose/guides/build-a-bitcoin-oracle
Build an on-chain Bitcoin price oracle using Compose, CoinGecko, and contract codegen
This guide walks you through building a Bitcoin price oracle that fetches the BTC/USD price every minute and writes it on-chain. It demonstrates cron triggers, contract codegen, external API calls, and collection storage.
## How it works
```mermaid theme={"dark"}
flowchart LR
A[Cron Trigger] -->|"every minute"| B[Compose Task]
B -->|"fetch price"| C[CoinGecko API]
C -->|"BTC/USD price"| B
B -->|"oracle.write(timestamp, price)"| D[On-chain Contract]
B -->|"insertOne"| E[Collection]
```
1. **Cron trigger** fires every minute
2. **CoinGecko API** provides the current BTC/USD price
3. **On-chain contract** receives the price via a typed contract class
4. **Collection** stores the price for historical queries
## Prerequisites
* [Goldsky CLI installed](/installation)
## Project structure
```text theme={"dark"}
bitcoin-oracle/
├── compose.yaml # Compose configuration
├── tsconfig.json # TypeScript config
├── src/
│ ├── contracts/
│ │ └── PriceOracle.json # Contract ABI (generates typed class)
│ ├── lib/
│ │ └── utils.ts # toBytes32 helper
│ └── tasks/
│ └── bitcoin-oracle.ts # Main task
```
## Step 1: Set up the project
Clone the example repository:
```bash theme={"dark"}
git clone https://github.com/goldsky-io/documentation-examples.git
cd documentation-examples/compose/bitcoin-oracle
```
## Step 2: Generate contract types
The project includes a `PriceOracle.json` ABI in `src/contracts/`. Generate the typed contract class:
```bash theme={"dark"}
goldsky compose codegen
```
This creates a typed `PriceOracle` class in `.compose/generated/` that provides type-safe contract interaction.
## Step 3: Understand the task
The `bitcoin-oracle.ts` task handles everything:
```typescript theme={"dark"}
import { TaskContext } from "compose";
import { toBytes32 } from "../lib/utils";
const ORACLE_CONTRACT = "0x34a264BCD26e114eD6C46a15d0A3Ba1873CaA708";
export async function main(context: TaskContext) {
const { fetch, evm, collection } = context;
const wallet = await evm.wallet({ name: "bitcoin-oracle-wallet" });
// Instantiate the typed contract (generated from src/contracts/PriceOracle.json)
const oracle = new evm.contracts.PriceOracle(
ORACLE_CONTRACT,
evm.chains.polygonAmoy,
wallet
);
// Fetch Bitcoin price from CoinGecko API
const response = await fetch<{ bitcoin: { usd: number } }>(
"https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd",
{
max_attempts: 3,
initial_interval_ms: 1000,
backoff_factor: 2,
}
);
if (!response) {
throw new Error("Failed to fetch Bitcoin price");
}
const bitcoinPrice = response.bitcoin.usd;
const timestamp = Date.now();
// Convert to bytes32 format and write on-chain
const timestampAsBytes32 = toBytes32(timestamp);
const priceAsBytes32 = toBytes32(Math.round(bitcoinPrice * 100));
const { hash, receipt } = await oracle.write(timestampAsBytes32, priceAsBytes32);
// Store in a collection for historical queries
const priceHistory = await collection("bitcoin_prices");
const { id } = await priceHistory.insertOne({
price: bitcoinPrice,
timestamp: timestamp,
});
return {
success: true,
oracleHash: hash,
price: bitcoinPrice,
timestamp,
priceId: id,
};
}
```
### Key Compose features used
* **`context.fetch`**: HTTP requests with built-in retry and backoff
* **`evm.wallet`**: managed wallet with gas sponsorship
* **`evm.contracts.PriceOracle`**: typed contract class generated from ABI JSON via `compose codegen`
* **`collection`**: persistent document storage for price history
## Step 4: Configure the Compose app
The `compose.yaml` uses a cron trigger to run every minute:
```yaml theme={"dark"}
name: "bitcoin-oracle"
api_version: "stable"
tasks:
- path: "./src/tasks/bitcoin-oracle.ts"
name: "bitcoin_oracle"
triggers:
- type: "cron"
expression: "* * * * *"
retry_config:
max_attempts: 2
initial_interval_ms: 1000
backoff_factor: 1
```
## Step 5: Run locally
```bash theme={"dark"}
goldsky compose start --fork-chains
```
`--fork-chains` lets you run a smart wallet locally. You can also use a private key wallet for your local Compose app. See more [here](/compose/secrets).
The task runs immediately and then every minute. You should see logs showing the fetched price and transaction hash.
## Step 6: Deploy to Goldsky
```bash theme={"dark"}
goldsky compose deploy
```
## Customization
### Change the price source
Replace the CoinGecko URL with any API that returns a JSON price:
```typescript theme={"dark"}
const response = await fetch<{ price: number }>(
"https://your-api.com/price",
{ max_attempts: 3, initial_interval_ms: 1000, backoff_factor: 2 }
);
```
### Use your own contract
1. Drop your contract's ABI JSON into `src/contracts/MyContract.json`
2. Run `goldsky compose codegen` to generate the typed class
3. Use it in your task:
```typescript theme={"dark"}
const myContract = new evm.contracts.MyContract(
"0xYOUR_CONTRACT_ADDRESS",
evm.chains.baseSepolia,
wallet
);
await myContract.yourMethod(arg1, arg2);
```
### Change the cron schedule
```yaml theme={"dark"}
triggers:
- type: "cron"
expression: "*/5 * * * *" # every 5 minutes
```
## Resources
* [Compose introduction](/compose/introduction)
* [Contract codegen](/compose/context/evm/contracts)
* [Task triggers](/compose/task-triggers)
* [Collections](/compose/context/collections)
* [CoinGecko API](https://www.coingecko.com/en/api)
* [GitHub repository](https://github.com/goldsky-io/documentation-examples/tree/main/compose/bitcoin-oracle)
# Build a compliance oracle
Source: https://docs.goldsky.com/compose/guides/build-a-compliance-oracle
Build a compliance-gated USDC payment gateway using Compose and the Webacy AML API
This guide walks you through building a compliance-gated payment gateway. A smart contract accepts a USDC payment and holds it in escrow. A Compose task screens the sender's wallet against the [Webacy](https://developers.webacy.co) AML risk API, then calls back on-chain to either approve the transfer (funds go to the business wallet) or reject it (funds return to the sender). Every decision is written to a durable collection as an audit trail, and a reconciliation cron catches any transfer left stuck in escrow.
It demonstrates on-chain event triggers, secrets, private-key wallets with sponsored gas, external API calls, collection storage, and cron triggers. For more on how Goldsky supports AML and sanctions-screening workflows, see [Compliance monitoring](/solutions/compliance-monitoring).
## How it works
```mermaid theme={"dark"}
flowchart LR
A[Sender] -->|"requestTransfer"| B[Escrow Contract]
B -->|"emit TransferRequested"| C[Compose Task]
C -->|"screen sender"| D[Webacy AML API]
D -->|"risk score"| C
C -->|"approveTransfer / rejectTransfer"| B
C -->|"audit record"| E[Collection]
```
1. **Sender** approves the escrow contract to spend USDC, then calls `requestTransfer`
2. **Escrow contract** pulls the funds in and emits a `TransferRequested` event
3. **Compose task** is triggered by the event and screens the sender via the Webacy API
4. **Oracle wallet** signs `approveTransfer` (funds to the business wallet) or `rejectTransfer` (funds back to the sender), with gas sponsored
5. **Collection** stores an audit record of the screening result and the decision
6. A separate **reconcile cron** runs every 5 minutes and alerts on transfers stuck in `Pending`
The escrow contract's `approveTransfer` and `rejectTransfer` functions are restricted to a single oracle address fixed at deployment. That is the security model (only the oracle can release escrowed funds), but it also means there is no shared contract to point your app at. Every deployment binds its own oracle wallet, so you deploy your own contract in this guide.
## Prerequisites
* [Goldsky CLI installed](/installation)
* [Foundry](https://book.getfoundry.sh/getting-started/installation) for contract deployment
* A [Webacy API key](https://developers.webacy.co) (a demo key is available after signup)
* A small amount of Base Sepolia ETH to deploy the contracts (runtime transactions are gas-sponsored)
## Project structure
```text theme={"dark"}
compliance-oracle/
├── compose.yaml # Compose configuration
├── tsconfig.json # TypeScript config
├── foundry.toml # Foundry config
├── contracts/
│ ├── ComplianceGatedTransfer.sol # Escrow contract
│ └── MockUSDC.sol # Test USDC (Base Sepolia only)
├── src/
│ ├── lib/
│ │ ├── constants.ts # Chain and contract config
│ │ └── webacy.ts # Webacy screening client
│ └── tasks/
│ ├── on-transfer-requested.ts # Main screening task
│ └── reconcile.ts # Safety-net cron
```
## Step 1: Set up the project
Create the project layout:
```bash theme={"dark"}
mkdir -p compliance-oracle/src/tasks compliance-oracle/src/lib compliance-oracle/contracts
cd compliance-oracle
```
The escrow contract imports OpenZeppelin's `IERC20`, so install the contracts library:
```bash theme={"dark"}
forge install OpenZeppelin/openzeppelin-contracts --no-commit
```
Add a `foundry.toml`:
```toml theme={"dark"}
[profile.default]
src = "contracts"
out = "out"
libs = ["lib"]
```
And a `tsconfig.json` for the Compose tasks:
```json theme={"dark"}
{
"compilerOptions": {
"target": "ES2022",
"module": "ES2022",
"moduleResolution": "bundler",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"outDir": "./dist",
"baseUrl": ".",
"paths": {
"compose": [".compose/types.d.ts"]
}
},
"include": ["src/**/*.ts"]
}
```
Add a `.gitignore` containing `.env`, `lib/`, and `.compose/`. You will store a real private key in `.env` shortly.
## Step 2: Write the escrow contract
`ComplianceGatedTransfer.sol` is a single-payee escrow. `requestTransfer` pulls USDC from the sender and records it as `Pending`. On approval, the funds go to the `oracle` (business) wallet; on rejection, they return to the sender. Both decision functions are `onlyOracle`:
```solidity theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
contract ComplianceGatedTransfer {
enum Status { Pending, Approved, Rejected }
struct Transfer {
address sender;
uint256 amount;
Status status;
}
IERC20 public immutable usdc;
address public oracle;
uint256 public nextTransferId;
mapping(uint256 => Transfer) public transfers;
event TransferRequested(
uint256 indexed id,
address indexed sender,
uint256 amount
);
event TransferApproved(uint256 indexed id);
event TransferRejected(uint256 indexed id);
event OracleUpdated(address indexed oldOracle, address indexed newOracle);
modifier onlyOracle() {
require(msg.sender == oracle, "not oracle");
_;
}
constructor(address _usdc, address _oracle) {
usdc = IERC20(_usdc);
oracle = _oracle;
}
/// @notice User calls this to send a compliance-screened payment.
/// User must have approved this contract to spend `amount` of USDC first.
/// If approved, funds go to the oracle (business) wallet.
function requestTransfer(uint256 amount) external {
require(amount > 0, "zero amount");
usdc.transferFrom(msg.sender, address(this), amount);
uint256 id = nextTransferId++;
transfers[id] = Transfer({
sender: msg.sender,
amount: amount,
status: Status.Pending
});
emit TransferRequested(id, msg.sender, amount);
}
/// @notice Oracle approves the transfer — funds go to the oracle (business) wallet.
function approveTransfer(uint256 id) external onlyOracle {
Transfer storage t = transfers[id];
require(t.status == Status.Pending, "not pending");
t.status = Status.Approved;
usdc.transfer(oracle, t.amount);
emit TransferApproved(id);
}
/// @notice Oracle rejects the transfer — funds returned to sender.
function rejectTransfer(uint256 id) external onlyOracle {
Transfer storage t = transfers[id];
require(t.status == Status.Pending, "not pending");
t.status = Status.Rejected;
usdc.transfer(t.sender, t.amount);
emit TransferRejected(id);
}
/// @notice Allow oracle address to be updated (for key rotation).
function setOracle(address _oracle) external onlyOracle {
emit OracleUpdated(oracle, _oracle);
oracle = _oracle;
}
}
```
Native USDC only exists on mainnet, so for Base Sepolia also add `MockUSDC.sol`, a mintable 6-decimal ERC-20 with an open `mint` so you can fund test wallets freely:
```solidity theme={"dark"}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
contract MockUSDC is ERC20 {
constructor() ERC20("Mock USDC", "USDC") {}
function decimals() public pure override returns (uint8) {
return 6;
}
/// @notice Open mint — testnet only.
function mint(address to, uint256 amount) external {
_mint(to, amount);
}
}
```
## Step 3: Create the oracle wallet and deploy the contracts
The oracle is a plain EOA. Its address becomes the contract's `oracle` at construction, and the same private key signs the Compose callbacks at runtime. If they don't match, every callback reverts with `not oracle`. Generate one:
```bash theme={"dark"}
cast wallet new
```
Save the private key in a `.env` file in the project root (never commit this file):
```env theme={"dark"}
ORACLE_PRIVATE_KEY=0x_your_oracle_private_key
RPC_URL=https://sepolia.base.org
WEBACY_API_KEY=your_webacy_api_key
```
The oracle EOA only needs gas for these two contract deploys. Runtime callbacks are sponsored. Fund it with a small amount of Base Sepolia ETH from a [faucet](https://www.alchemy.com/faucets/base-sepolia) if `cast balance` shows zero.
Deploy MockUSDC first, then the escrow with the token and oracle addresses as constructor args:
```bash theme={"dark"}
source .env
ORACLE_ADDRESS=$(cast wallet address "$ORACLE_PRIVATE_KEY")
# 1) MockUSDC
forge create contracts/MockUSDC.sol:MockUSDC \
--rpc-url "$RPC_URL" --private-key "$ORACLE_PRIVATE_KEY" --broadcast
# save "Deployed to:" as USDC_ADDRESS
# 2) ComplianceGatedTransfer(usdc, oracle)
forge create contracts/ComplianceGatedTransfer.sol:ComplianceGatedTransfer \
--rpc-url "$RPC_URL" --private-key "$ORACLE_PRIVATE_KEY" --broadcast \
--constructor-args "$USDC_ADDRESS" "$ORACLE_ADDRESS"
# save "Deployed to:" as CONTRACT_ADDRESS
```
Save both deployed addresses. You'll wire them into the app next.
## Step 4: Configure the Compose app
The `compose.yaml` declares two secrets and two tasks: an on-chain event listener for `TransferRequested` and the reconcile cron. Fill in your escrow contract address:
```yaml theme={"dark"}
name: "compliance-oracle"
api_version: "stable"
secrets:
- ORACLE_PRIVATE_KEY
- WEBACY_API_KEY
tasks:
- path: "./src/tasks/on-transfer-requested.ts"
name: "on_transfer_requested"
triggers:
- type: "onchain_event"
network: "base_sepolia"
contract: "0xYOUR_ESCROW_CONTRACT_ADDRESS"
events:
- "TransferRequested(uint256,address,uint256)"
retry_config:
max_attempts: 3
initial_interval_ms: 1000
backoff_factor: 2
- path: "./src/tasks/reconcile.ts"
name: "reconcile"
triggers:
- type: "cron"
expression: "*/5 * * * *"
```
The task code reads its chain and addresses from `src/lib/constants.ts`. Fill in the same escrow address plus your MockUSDC address:
```typescript theme={"dark"}
import type { Hex } from "compose";
export const CONFIG = {
chain: "baseSepolia" as const,
// Your deployed ComplianceGatedTransfer contract
contractAddress: "0xYOUR_ESCROW_CONTRACT_ADDRESS" as Hex,
// Your MockUSDC on Base Sepolia (native USDC on mainnet)
usdcAddress: "0xYOUR_USDC_ADDRESS" as Hex,
usdcDecimals: 6,
};
// Webacy risk score threshold (0-100 scale)
// Transfers from wallets scoring at or above this are rejected
export const RISK_THRESHOLD = 50;
```
The chain appears in both files, in different formats: camelCase in TypeScript (`baseSepolia`) and snake\_case in the manifest (`base_sepolia`). Updating only one of them is the most common reason the task never fires.
## Step 5: Add the screening library
`src/lib/webacy.ts` fetches Webacy's risk report for an address and normalizes it into a pass/fail result. A sender fails when its `overallRisk` score is at or above `RISK_THRESHOLD`; tags with severity 2 or higher are surfaced as the triggered rules:
```typescript theme={"dark"}
import { TaskContext } from "compose";
export type WalletScreeningResult = {
address: string;
riskScore: number | null;
passed: boolean;
triggeredRules: string[];
};
type WebacyIssueTag = {
name: string;
description: string;
severity: number;
key: string;
};
type WebacyIssue = {
score: number;
tags: WebacyIssueTag[];
};
type WebacyResponse = {
count: number;
medium: number;
high: number;
overallRisk: number;
addressType: string;
issues: WebacyIssue[];
};
const WEBACY_API_BASE = "https://api.webacy.com";
export async function screenWallet(
address: string,
apiKey: string,
riskThreshold: number,
fetchFn: TaskContext["fetch"],
): Promise {
const url = `${WEBACY_API_BASE}/addresses/${address}?chain=base`;
const data = await fetchFn(url, {
method: "GET",
headers: {
"x-api-key": apiKey,
},
});
if (!data) {
throw new Error(`Webacy API returned empty response for ${address}`);
}
const riskScore = data.overallRisk ?? null;
const triggeredRules: string[] = (data.issues ?? [])
.flatMap((issue) => issue.tags ?? [])
.filter((tag) => tag.severity >= 2)
.map((tag) => tag.name);
return {
address,
riskScore,
passed: riskScore === null || riskScore < riskThreshold,
triggeredRules,
};
}
```
Webacy is one screening provider. The same pattern works with any AML or sanctions API that scores an address. See [Compliance monitoring](/solutions/compliance-monitoring) for the broader screening patterns Goldsky supports.
## Step 6: Write the main task
`src/tasks/on-transfer-requested.ts` runs the whole decision flow: decode the event, screen the sender, sign the callback with the oracle key, and persist an audit record to the `transfer-audits` collection:
```typescript theme={"dark"}
import { TaskContext, OnchainEvent } from "compose";
import { CONFIG, RISK_THRESHOLD } from "../lib/constants";
import { screenWallet, WalletScreeningResult } from "../lib/webacy";
type TransferAuditRecord = {
transferId: string;
sender: string;
amount: string;
screening: WalletScreeningResult;
decision: "approved" | "rejected";
reason: string;
depositTxHash: string;
oracleTxHash: string;
timestamp: string;
};
type TransferRequestedEvent = {
eventName: "TransferRequested";
args: { id: bigint; sender: string; amount: bigint };
};
function formatUsdc(raw: bigint): string {
return `${(Number(raw) / 1e6).toFixed(2)} USDC`;
}
export async function main(ctx: TaskContext, payload: OnchainEvent) {
const { evm, collection, env, fetch: ctxFetch } = ctx;
const log = ctx.logger;
// --- Step 1: Decode the onchain event ---
const decoded = await evm.decodeEventLog(
[{
type: "event",
name: "TransferRequested",
inputs: [
{ name: "id", type: "uint256", indexed: true },
{ name: "sender", type: "address", indexed: true },
{ name: "amount", type: "uint256", indexed: false },
],
}],
payload,
);
const { id, sender, amount } = decoded.args;
const transferId = id.toString();
const depositTxHash = (payload as any).transaction_hash;
log.info(`deposit received: ${formatUsdc(amount)}, from ${sender}`);
// --- Step 2: Screen the depositor via Webacy ---
log.info(`screening depositor ${sender}`);
const screenResult = await screenWallet(sender, env.WEBACY_API_KEY, RISK_THRESHOLD, ctxFetch);
log.info(`screening complete for ${sender}, risk score: ${screenResult.riskScore}`);
// --- Step 3: Call back to the escrow contract ---
const wallet = await evm.wallet({ privateKey: env.ORACLE_PRIVATE_KEY, sponsorGas: true });
let txHash: string;
let decision: "approved" | "rejected";
let reason: string;
if (screenResult.passed) {
decision = "approved";
reason = `Sender score: ${screenResult.riskScore}. Below threshold ${RISK_THRESHOLD}.`;
log.info(`approving transfer #${transferId} — ${formatUsdc(amount)} to vault wallet`);
const result = await wallet.writeContract(
evm.chains[CONFIG.chain],
CONFIG.contractAddress,
"approveTransfer(uint256)",
[id],
);
txHash = result.hash;
log.info(`transfer #${transferId} APPROVED`, {
oracleTxHash: txHash,
amount: formatUsdc(amount),
sender,
});
} else {
decision = "rejected";
reason = `Sender flagged (score: ${screenResult.riskScore}, rules: ${screenResult.triggeredRules.join(", ")})`;
log.warn(`rejecting transfer #${transferId} — returning ${formatUsdc(amount)} to ${sender}`);
const result = await wallet.writeContract(
evm.chains[CONFIG.chain],
CONFIG.contractAddress,
"rejectTransfer(uint256)",
[id],
);
txHash = result.hash;
}
// --- Step 4: Persist audit record ---
const audits = await collection("transfer-audits");
await audits.setById(transferId, {
transferId,
sender,
amount: amount.toString(),
screening: screenResult,
decision,
reason,
depositTxHash,
oracleTxHash: txHash,
timestamp: new Date().toISOString(),
});
log.info(`audit record saved for transfer #${transferId}`);
return { transferId, decision, reason, depositTxHash, oracleTxHash: txHash };
}
```
### Key Compose features used
* **`evm.decodeEventLog`**: decodes the raw event payload into typed args, no external ABI library needed
* **`evm.wallet({ privateKey, sponsorGas: true })`**: loads the oracle EOA from the `ORACLE_PRIVATE_KEY` secret with sponsored gas, so the wallet never needs native token at runtime
* **`context.fetch`**: HTTP client used by the Webacy screening call
* **`collection`**: the `transfer-audits` collection is a durable, queryable audit trail keyed by transfer ID
* **`retry_config`**: transient Webacy or RPC failures retry the whole task (3 attempts with backoff)
Don't import `viem`, `ethers`, or other external packages in task code: `evm`, `fetch`, `collection`, `env`, and `logger` all come from the injected context. The only import from outside your project is `compose` itself, for types.
## Step 7: Add the reconciliation cron
Escrow that silently holds funds is the failure mode to design against. `src/tasks/reconcile.ts` runs every 5 minutes, scans the contract for transfers still in `Pending` (a missed event or a failed callback) and logs an error so nothing sits in escrow unnoticed:
```typescript theme={"dark"}
import { TaskContext } from "compose";
import { CONFIG } from "../lib/constants";
export async function main(ctx: TaskContext) {
const { evm } = ctx;
// Use the oracle private key for read calls (address must match the contract's oracle)
const wallet = await evm.wallet({ privateKey: ctx.env.ORACLE_PRIVATE_KEY });
// Read how many transfers exist on the contract
const totalTransfers = await wallet.readContract(
evm.chains[CONFIG.chain],
CONFIG.contractAddress,
"nextTransferId() returns (uint256)",
[],
);
// Check each transfer's status onchain
// In production you'd track a cursor; for the demo, scan all
let pendingCount = 0;
const staleTransfers: number[] = [];
for (let i = 0; i < Number(totalTransfers); i++) {
const transfer = await wallet.readContract<[string, bigint, number]>(
evm.chains[CONFIG.chain],
CONFIG.contractAddress,
"transfers(uint256) returns (address,uint256,uint8)",
[i],
);
const status = transfer[2]; // 0 = Pending, 1 = Approved, 2 = Rejected
if (status === 0) {
pendingCount++;
staleTransfers.push(i);
}
}
const report = {
timestamp: new Date().toISOString(),
totalTransfers: Number(totalTransfers),
pendingCount,
staleTransferIds: staleTransfers,
healthy: pendingCount === 0,
};
if (pendingCount > 0) {
ctx.logger.error("stale pending transfers detected", report);
} else {
ctx.logger.info("reconciliation passed", report);
}
return report;
}
```
## Step 8: Set the secrets
The deployed app needs the oracle key (to sign callbacks) and the Webacy key (to screen). Set both as Compose secrets:
```bash theme={"dark"}
source .env
goldsky compose secret set ORACLE_PRIVATE_KEY --value "$ORACLE_PRIVATE_KEY"
goldsky compose secret set WEBACY_API_KEY --value "$WEBACY_API_KEY"
```
Both names must appear under `secrets:` in `compose.yaml` (they do, from Step 4) for the values to be injected into `ctx.env` at runtime. See [Wallets and secrets](/compose/secrets) for details.
## Step 9: Deploy to Goldsky
```bash theme={"dark"}
goldsky compose deploy
```
The first deploy can take a minute or two. Once it reports `Deployed compose app: compliance-oracle`, both the event listener and the reconcile cron are live.
## Step 10: Test the flow
Drive the full flow from a separate sender wallet (not the oracle key). First mint test USDC to the sender (the MockUSDC has an open `mint`):
```bash theme={"dark"}
cast send $USDC_ADDRESS "mint(address,uint256)" $SENDER_ADDRESS 1000000 \
--rpc-url $RPC_URL --private-key $ORACLE_PRIVATE_KEY # 1.00 USDC
```
Then approve the escrow as a spender and request the transfer (ERC-20 pulls require prior approval):
```bash theme={"dark"}
cast send $USDC_ADDRESS "approve(address,uint256)" $CONTRACT_ADDRESS 1000000 \
--rpc-url $RPC_URL --private-key $SENDER_KEY
cast send $CONTRACT_ADDRESS "requestTransfer(uint256)" 1000000 \
--rpc-url $RPC_URL --private-key $SENDER_KEY
```
Watch the decision land in the logs:
```bash theme={"dark"}
goldsky compose logs
```
You should see `deposit received`, `screening complete ... risk score N`, then `transfer #0 APPROVED` (or a rejection warning) with an `oracleTxHash`. Confirm on-chain that the transfer's status is `1` (Approved) or `2` (Rejected), not `0`:
```bash theme={"dark"}
cast call $CONTRACT_ADDRESS "transfers(uint256)(address,uint256,uint8)" 0 --rpc-url $RPC_URL
```
A fresh testnet wallet has no on-chain history, so Webacy scores it low and the transfer is approved. To exercise the reject path, screen a known-flagged address or test on mainnet where real risk data exists.
## Troubleshooting
* **`approveTransfer`/`rejectTransfer` reverts with `not oracle`.** The Compose wallet's address doesn't match the contract's `oracle`. Both must derive from the same `ORACLE_PRIVATE_KEY`. Check that `cast call $CONTRACT_ADDRESS "oracle()(address)" --rpc-url $RPC_URL` equals `cast wallet address $ORACLE_PRIVATE_KEY`.
* **`requestTransfer` reverts with "transfer amount exceeds allowance".** The sender didn't `approve` the escrow to spend their USDC first.
* **Task never fires.** Confirm the `contract:` and `network:` in `compose.yaml` match where you deployed, and that `chain` in `constants.ts` agrees. Check the trigger is active with `goldsky compose status`.
* **Webacy returns an empty response.** Check `WEBACY_API_KEY` is set as a secret and valid. Transient failures are absorbed by the task's `retry_config`.
* **Edits don't take effect after redeploy.** Stale bundle cache: run `rm -rf .compose/` and redeploy.
* **`insufficient funds for gas` on deploy.** Only the contract deploy needs gas on the oracle EOA. Fund it from a faucet; runtime callbacks are sponsored.
## Going to production
### Use Base mainnet and native USDC
Skip MockUSDC and deploy `ComplianceGatedTransfer` with native USDC on Base (`0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`) as the `_usdc` constructor arg. Then update the chain in both places: `chain: "base"` in `src/lib/constants.ts` and `network: "base"` in `compose.yaml`. Real risk data also makes the reject path meaningful: flagged mainnet wallets will actually score above the threshold.
### The security model
Each deployment binds one oracle address, fixed at construction. Only that key can release escrow, so never share `ORACLE_PRIVATE_KEY`, never commit it, and never log it. It exists only in your `.env` and as a Compose secret. If the key is compromised, rotate it: call `setOracle` from the old key with the new oracle address, update the `ORACLE_PRIVATE_KEY` secret, and redeploy.
### Tune the risk threshold
`RISK_THRESHOLD` in `constants.ts` sets the cutoff on Webacy's 0-100 scale. A lower threshold rejects more aggressively; where to set it depends on your risk policy. The `transfer-audits` collection keeps the full screening result (score and triggered rules) for every decision, so you can review past decisions when calibrating. See [Compliance monitoring](/solutions/compliance-monitoring) for guidance on screening policies.
### Harden the reconciler
The demo cron scans every transfer from ID 0 on each run and only logs. In production, track a cursor in a collection so each run scans only new transfers, and consider having the reconciler re-screen and resolve stale `Pending` transfers itself rather than just alerting.
## Resources
* [Compose introduction](/compose/introduction)
* [Task triggers](/compose/task-triggers)
* [Wallets and secrets](/compose/secrets)
* [Collections](/compose/context/collections)
* [Compliance monitoring](/solutions/compliance-monitoring)
* [Webacy developer docs](https://developers.webacy.co)
# Build a corporate-actions distributor
Source: https://docs.goldsky.com/compose/guides/build-a-corporate-actions-distributor
Pay N share-token holders pro-rata for a tokenized corporate action (dividend, coupon, rebate, airdrop) using Compose to orchestrate an on-demand Goldsky Turbo pipeline as the snapshot subroutine
This guide walks you through building a corporate-actions distributor: an HTTP-triggered Compose task that snapshots holders of a share token at an operator-supplied record block, then pays each holder their pro-rata share of an escrowed USDC pool. Compose orchestrates Goldsky Turbo as an ephemeral, on-demand subroutine. When a campaign is declared, the task spawns a one-shot [job-mode](/turbo-pipelines/job-mode) pipeline to snapshot holders, waits for it to finish, pays each holder, and deletes the pipeline. There is no always-on indexing.
## How it works
```mermaid theme={"dark"}
flowchart LR
Op([Operator]) -->|POST campaignId, recordBlock, totalAmount| T[declare_campaign task]
T -->|1. approve + declare| C[DistributionCampaign.sol]
T -->|2. POST /api/v1/pipelines| P[Turbo job-mode pipeline]
P -->|3. backfill Transfers| DB[(share_balances_id
per-campaign table)]
T -->|4. poll /state every 2s| P
T -->|5. read snapshot via SQL| DB
T -->|6. pay each holder (25 concurrent)| C
T -->|7. read escrowRemaining| C
T -->|8. DELETE pipeline + drop table| P
```
One HTTP request drives the entire lifecycle. No cron, no off-chain handoff:
1. The operator declares a distribution by `POST`ing `{ campaignId, recordBlock, totalAmount }`. The task validates `recordBlock <= currentBlock`, approves USDC, and calls `DistributionCampaign.declare()`, which atomically pulls the escrow.
2. The same task spawns a job-mode Turbo pipeline filtered to the share-token contract over `block_number BETWEEN AND `. The planner prunes everything outside that window. The sink writes raw `Transfer` rows into a per-campaign Postgres table.
3. The task polls `/state` every 2 seconds until the pipeline reports `completed` (or its k8s deployment auto-cleans up after a successful run, which we infer from `state=unknown` plus the table having rows).
4. The task reads the snapshot with a SQL aggregate over the raw rows (`SUM(credits) - SUM(debits)` per account) and computes pro-rata. Each holder gets `floor(balance × totalAmount / totalSupply)`. The floor remainder goes to the last holder so the sum equals `totalAmount` exactly.
5. The task fires up to 25 sponsored `pay()` calls concurrently via `Promise.allSettled`. Already-paid holders are filtered out by an on-chain `isPaid()` read first. The contract's `require(!paid[id][holder])` guard means duplicates are structurally impossible anyway.
6. The task re-reads `escrowRemaining` on-chain to confirm completion. Zero means done: mark the campaign `complete`, `DELETE` the pipeline, drop the per-campaign table. Non-zero means the operator can re-POST the same `campaignId` to resume.
Re-posting the same `campaignId` after any kind of failure picks up cleanly. The contract is the sole source of truth for "did this holder get paid?", so Compose's state machine never has to be.
## Prerequisites
* [Goldsky CLI installed](/installation)
* [Foundry](https://book.getfoundry.sh/getting-started/installation) for the contract deploys
* A small amount of ETH on Base mainnet for the three contract deploys (around 0.0005 ETH)
* A project API key for `goldsky compose deploy -t ` and a separate (or same) key set as the `GOLDSKY_PROJECT_KEY` secret so the running app can manage Turbo pipelines
## Project structure
```text theme={"dark"}
corporate-actions/
├── compose.yaml # 1 HTTP task; declares GOLDSKY_PROJECT_KEY secret
├── contracts/
│ ├── ShareToken.sol # Minimal ERC-20, pre-mints to 25 demo holders
│ ├── MockUSDC.sol # 6-decimal mock with permissionless mint
│ └── DistributionCampaign.sol # AlreadyPaid guard, escrow, audit events
├── scripts/
│ ├── seed-holders.json # 25 demo holders, uneven amounts
│ └── deploy.sh # forge create x3 in one go
└── src/
├── lib/
│ ├── constants.ts # CONFIG, polling cadence, concurrency
│ ├── turbo.ts # /api/v1/pipelines client + snapshot pipeline builder
│ ├── db.ts # Neon HTTP /sql client (via context.fetch)
│ └── driver.ts # state-machine driver: snapshot → paying → complete
└── tasks/
└── declare-campaign.ts # HTTP trigger; drives full lifecycle inline
```
## Step 1: Set up the project
Clone the example repository:
```bash theme={"dark"}
git clone https://github.com/goldsky-io/documentation-examples.git
cd documentation-examples/compose/corporate-actions
```
## Step 2: Understand the task
`declare-campaign.ts` is the only task. It validates input, approves USDC, declares the campaign on-chain, spawns the pipeline, and drives the campaign through its state machine inside the HTTP request:
```typescript theme={"dark"}
export async function main(context: TaskContext, params?: DeclareParams) {
const { evm, collection } = context;
// Idempotent on campaignId. A second POST drives an existing campaign
// forward instead of declaring a new one.
const campaigns = await collection("campaigns", [
{ path: "status", type: "text" },
]);
const existing = await campaigns.getById(params.campaignId.toLowerCase());
if (existing) {
await driveCampaign(context, campaigns, existing);
return responseFor(existing, "resumed");
}
// Approve + declare on-chain (atomic escrow pull).
const wallet = await evm.wallet({ name: "corp-actions-operator", sponsorGas: true });
await wallet.writeContract(chain, payToken, "approve(address,uint256)", [campaignContract, totalAmount]);
const { hash } = await wallet.writeContract(chain, campaignContract,
"declare(bytes32,address,address,uint256)",
[campaignId, payToken, shareToken, totalAmount]);
// Spawn the snapshot pipeline.
const pipeline = await createSnapshotPipeline(context, { campaignId, shareToken, recordBlock });
// Persist campaign metadata, then drive the campaign through
// snapshot → paying → complete inline.
await campaigns.setById(rowId, { ...campaign, status: "snapshotting", pipelineName: pipeline.name });
await driveCampaign(context, campaigns, campaign);
return responseFor(campaign, "declared");
}
```
The lifecycle logic lives in `src/lib/driver.ts`. `driveCampaign` is a state-machine dispatcher: `snapshotting` polls the pipeline, then transitions to `paying`; `paying` reads the snapshot, fires `pay()` calls, then checks `escrowRemaining` to decide whether to mark `complete`.
### Key Compose features used
* **Compose orchestrating Turbo** via the v1 pipelines REST API. The task spawns, polls, and deletes the pipeline from inside its own HTTP handler.
* **Auto-provisioned hosted Neon DB.** Compose-cloud creates a per-app Neon project and a `CORPORATE_ACTIONS` project secret pointing at it. Turbo writes to that DB via the same secret. No glue code on either side.
* **Gas-sponsored writes.** `sponsorGas: true` on `evm.wallet()` means the operator wallet never holds ETH. Goldsky pays gas for every `approve()` and `pay()`.
* **`context.fetch` for everything external.** The Neon HTTP `/sql` client, the v1 pipelines API client, and the chain RPC reads all go through `context.fetch`. That's the only `--allow-net` egress path the task gets.
* **Resumable on `campaignId`.** Compose's collection holds campaign metadata. The contract holds payment truth. Re-POSTing the same id drives the existing row forward.
## Step 3: Understand the contracts
`DistributionCampaign.sol` is the core piece. It holds USDC in escrow, gates payouts on a per-holder `paid` bitmap, and emits a rich audit event:
```solidity theme={"dark"}
struct Campaign {
address operator;
address payToken;
address shareToken;
uint256 totalAmount;
uint256 escrowRemaining;
uint256 declaredAt;
bool declared;
bool sealed;
}
function declare(bytes32 userId, address payToken, address shareToken, uint256 totalAmount) external;
function pay(bytes32 id, address holder, uint256 amount, uint256 sharesAtSnapshot) external;
function isPaid(bytes32 id, address holder) external view returns (bool);
function seal(bytes32 id) external; // operator can recover unspent escrow
event HolderPaid(
bytes32 indexed id,
address indexed holder,
address indexed payToken,
uint256 amount,
uint256 sharesAtSnapshot
);
```
A holder can never be paid twice, regardless of what Compose does:
```solidity theme={"dark"}
require(!paid[id][holder], "AlreadyPaid");
paid[id][holder] = true;
campaigns[id].escrowRemaining -= amount;
IERC20(payToken).transfer(holder, amount);
```
`ShareToken.sol` is a minimal ERC-20 that pre-mints to a demo holder set in its constructor. `MockUSDC.sol` is a 6-decimal mock with permissionless mint, so you can fund the operator without bridging real USDC.
## Step 4: Pre-create the operator wallet
The operator wallet is the address that calls `declare()` and `pay()` on the contract. Provision it ahead of the deploy so you can hard-code its address into the contract's deployment if you want to restrict who can call `declare()`:
```bash theme={"dark"}
goldsky compose wallet create corp-actions-operator --env cloud
```
The command prints the wallet address. Save it for the next step.
## Step 5: Deploy the contracts
`scripts/deploy.sh` deploys all three contracts in one run. It reads `seed-holders.json` to pre-mint share-token balances to 25 demo addresses:
```bash theme={"dark"}
PRIVATE_KEY=0x... ./scripts/deploy.sh
```
The script prints the three addresses and the ShareToken's deploy block. You need all four values in the next step.
## Step 6: Wire in the addresses
Open `src/lib/constants.ts` and replace the four constants:
```typescript theme={"dark"}
export const CONFIG = {
chain: "base" as const,
shareToken: "0x..." as Hex, // from step 5
payToken: "0x..." as Hex, // MockUSDC from step 5
campaignContract: "0x..." as Hex, // from step 5
shareTokenDeployBlock: 45654954, // block number printed by deploy.sh
};
```
`shareTokenDeployBlock` matters for performance. The job-mode source has to be set to `start_at: "earliest"` (the source-level `end_block` would make it non-hybrid and Turbo refuses to run). So we anchor the scan window in the SQL filter instead: `block_number BETWEEN AND `. The planner prunes everything outside that window before it touches a row.
## Step 7: Set the project secret
The running compose app needs a Goldsky project API key so it can spawn, poll, and delete Turbo pipelines via the v1 API. Set it once:
```bash theme={"dark"}
goldsky secret create GOLDSKY_PROJECT_KEY
```
You don't have to create the `CORPORATE_ACTIONS` secret. Compose-cloud provisions a Neon DB for the app on first deploy and creates that secret for you, pointed at the new DB.
## Step 8: Deploy to Goldsky
```bash theme={"dark"}
goldsky compose deploy
```
The compose-cloud deploy will:
1. Provision a hosted Neon DB for the app.
2. Create the `CORPORATE_ACTIONS` project secret pointed at it.
3. Build and start the task pod. The HTTP trigger is now reachable at `https://api.goldsky.com/api/admin/compose/v1/corporate-actions/tasks/declare_campaign`.
## Step 9: Declare a campaign and verify
Fund the operator wallet with MockUSDC (the address was printed at the end of `goldsky compose wallet create`):
```bash theme={"dark"}
cast send "mint(address,uint256)" 1000000000000 \
--rpc-url https://mainnet.base.org --private-key $PRIVATE_KEY
```
That mints 1,000,000 mUSDC, enough for many demo campaigns.
Pick a record block past finality, then POST:
```bash theme={"dark"}
RECORD_BLOCK=$(cast block-number --rpc-url https://mainnet.base.org)
RECORD_BLOCK=$((RECORD_BLOCK - 32))
curl -sX POST "https://api.goldsky.com/api/admin/compose/v1/corporate-actions/tasks/declare_campaign" \
-H "content-type: application/json" \
-H "Authorization: Bearer $GOLDSKY_TOKEN" \
-d "{
\"campaignId\": \"0x000000000000000000000000000000000000000000000000000000000000c0a1\",
\"recordBlock\": $RECORD_BLOCK,
\"totalAmount\": \"10000000000\"
}"
```
That declares a 10,000 mUSDC distribution. The request stays open for roughly 10 to 30 seconds while compose snapshots, computes pro-rata, and fires the 25 `pay()` calls in a single batch. The response body includes the final campaign state (`complete` on the happy path, or `paying` if it needs another drive call).
Verify on-chain:
```bash theme={"dark"}
cast call "getCampaign(bytes32)" \
--rpc-url https://mainnet.base.org
```
`escrowRemaining` is exactly 0 once all 25 holders are paid. The full audit trail is in the contract's `HolderPaid` events.
## Crash-safety walkthrough
The contract is the source of truth for "did this holder get paid?". Compose can crash any time and restart any time without double-paying or skipping a holder.
To verify:
1. POST a fresh campaign (new `campaignId`).
2. Mid-flight, pause the compose app: `goldsky compose pause`.
3. Resume: `goldsky compose resume`.
4. Re-POST the same `campaignId`. Within a single drive call, every remaining holder gets paid. There are zero duplicates on-chain. Verify by counting `HolderPaid` events for the campaign.
What's protecting you:
* **Compose's collection only stores campaign metadata** (status, declareTxHash, pipelineName, persisted payouts). It does not cache per-holder paid state, so there's no off-chain table that can diverge from on-chain truth.
* **Per-holder `isPaid()` check before each `pay()` call.** Already-paid holders are skipped before the tx is even attempted.
* **The contract's `require(!paid[id][holder], "AlreadyPaid")` guard.** Even if a stale tx arrives after restart, the contract rejects it. Double-pay is structurally impossible regardless of compose's state.
A pod kill mid-snapshot is also recoverable. Re-POSTing the same `campaignId` polls the existing pipeline. If the pipeline auto-cleaned up after success, we infer completion from the agg table having rows.
## Customization
### Why operator-supplied `recordBlock`
In real corporate actions, the record date is set in advance and is the cutoff for who gets the payout. The snapshot is by definition backwards-looking. So the operator passes an explicit `recordBlock`, typically a block past finality like `currentBlock - 32`. The pipeline backfills exactly that range and commits the snapshot. There's no live "wait for finality" gate inside compose. The operator already accommodated finality when they chose the block.
Future-dated record blocks (declare today, snapshot tomorrow) are a real corporate-action feature but out of scope for this demo.
### Swap the share token
Update `CONFIG.shareToken` and `CONFIG.shareTokenDeployBlock` in `src/lib/constants.ts` and redeploy the compose app. Each campaign's pipeline bakes in the address at declare time, so existing campaigns are unaffected.
### Add a chain
Add a `chain` discriminator to `Campaign` and `DeclareParams`, populate `CONFIG` with a per-chain map, and pass `chain` into `buildSnapshotPipeline` so the dataset name (`base.erc20_transfers` vs `arbitrum.erc20_transfers`) is parameterized.
### Use real USDC
Replace `MockUSDC.sol` with the real USDC address per chain in `CONFIG.payToken`. Real USDC isn't fee-on-transfer, so `escrowRemaining` math is exact.
### Tune concurrency
`CONCURRENCY` in `src/lib/constants.ts` is the upper bound on parallel `pay()` calls. The gas-sponsored bundler caps per-sender throughput around 1 to 5 userOps per second; the default of 25 is sized for the demo's 25-holder set firing in one visible batch. For larger distributions, drop it to keep the bundler happy.
## When NOT to use this pattern
This is push-based pro-rata. It scales comfortably up to roughly 100 holders per request. Beyond that, the right shape is a **merkle-claim contract** instead: the operator publishes one merkle root and holders pull. The compose plumbing (orchestrating Turbo for the snapshot, computing pro-rata, building the audit trail) carries over to either model. Only the on-chain shape changes.
## Resources
* [Compose introduction](/compose/introduction)
* [Task triggers](/compose/task-triggers)
* [EVM wallets & gas sponsoring](/compose/context/evm/wallets)
* [Turbo job-mode pipelines](/turbo-pipelines/job-mode)
* [CMTAT IncomeVault](https://github.com/CMTA/IncomeVault), Swiss-bank reference implementation for tokenized-equity dividends. The example's event schema is anchored on this convention.
* [ERC-1726 Dividend-Paying Token](https://github.com/Roger-Wu/erc1726-dividend-paying-token)
* [GitHub repository](https://github.com/goldsky-io/documentation-examples/tree/main/compose/corporate-actions)
# Build a multi-chain NAV oracle
Source: https://docs.goldsky.com/compose/guides/build-a-nav-oracle
Publish a tokenized fund's Net Asset Value to multiple chains on a schedule, with a Chainlink-compatible on-chain interface and an operator kill-switch
This guide walks you through building a Proof-of-Reserves / NAV oracle for a tokenized RWA fund. A single Compose task runs every 5 minutes, fetches a structured NAV bundle from a custodian endpoint, and publishes it to `ReserveAggregator` contracts on Base Sepolia and Arbitrum Sepolia in one run. The on-chain contract implements `AggregatorV3Interface`, so any existing Chainlink consumer can read it unchanged.
## How it works
```mermaid theme={"dark"}
flowchart LR
A[Cron Trigger] -->|every 5 min| B[Compose Task]
B -->|GET| C[Custodian Endpoint]
C -->|"{totalNav, cash, tbills, repo, asOf, ripcord}"| B
B -->|updateNav| D[ReserveAggregator on Base Sepolia]
B -->|updateNav| E[ReserveAggregator on Arbitrum Sepolia]
```
Each cycle:
1. **Fetch** the NAV bundle from a custodian JSON endpoint. If the response carries `ripcord: true`, the task logs a skip message and returns without publishing.
2. **Scale** human USD numbers to 18-decimal fixed point, matching Chainlink's convention for USD-denominated feeds.
3. **Publish** to both chains independently via `Promise.allSettled`. A failure on one chain does not block the other. The next cron cycle reconciles.
## Prerequisites
* [Goldsky CLI installed](/installation)
* [Foundry](https://book.getfoundry.sh/getting-started/installation) for contract deploys
* Testnet ETH on Base Sepolia and Arbitrum Sepolia to deploy the contracts
## Project structure
```text theme={"dark"}
nav-oracle/
├── compose.yaml # 1 cron task, 2 chains
├── mock-custodian.json # Default data source (swap for your API)
├── contracts/
│ └── ReserveAggregator.sol # AggregatorV3Interface-compatible publisher
└── src/
├── lib/
│ └── scaling.ts # USD → 18-decimal bigint helper
└── tasks/
└── nav-oracle.ts # The cron task
```
## Step 1: Set up the project
Clone the example repository:
```bash theme={"dark"}
git clone https://github.com/goldsky-io/documentation-examples.git
cd documentation-examples/compose/nav-oracle
```
## Step 2: Understand the task
`nav-oracle.ts` fetches the bundle, validates the ripcord, and publishes to both chains:
```typescript theme={"dark"}
import type { TaskContext } from "compose";
import { toScaled18 } from "../lib/scaling";
const CUSTODIAN_URL =
"https://raw.githubusercontent.com/goldsky-io/documentation-examples/main/compose/nav-oracle/mock-custodian.json";
const BASE_SEPOLIA_AGGREGATOR = "0x8099A30Ac752f86C77A0e0210085a908ba6d02fE";
const ARBITRUM_SEPOLIA_AGGREGATOR = "0x02D9Df62B7AED15739D638B92BAcEA2ce4Cb3d70";
export async function main(context: TaskContext) {
const { fetch, evm } = context;
// sponsorGas: true lets Goldsky pay gas for every write, so the publisher
// wallet never needs to be funded.
const wallet = await evm.wallet({
name: "nav-oracle-publisher",
sponsorGas: true,
});
const bundle = await fetch(CUSTODIAN_URL, {
max_attempts: 3,
initial_interval_ms: 1000,
backoff_factor: 2,
});
// Ripcord: operator kill-switch. Skip cleanly — not an error.
if (bundle.ripcord) {
console.log(`Ripcord engaged for ${bundle.accountName} — skipping publish.`);
return { success: true, skipped: "ripcord" };
}
const args = [
toScaled18(bundle.cash),
toScaled18(bundle.tbills),
toScaled18(bundle.repo),
toScaled18(bundle.totalNav),
BigInt(Math.floor(new Date(bundle.asOf).getTime() / 1000)),
];
const signature = "updateNav(uint256,uint256,uint256,uint256,uint64)";
const results = await Promise.allSettled([
wallet.writeContract(evm.chains.baseSepolia, BASE_SEPOLIA_AGGREGATOR, signature, args),
wallet.writeContract(evm.chains.arbitrumSepolia, ARBITRUM_SEPOLIA_AGGREGATOR, signature, args),
]);
// ... (summarize per-chain results, throw only if both failed)
}
```
### Key Compose features used
* **Multi-chain writes from a single task**: one `wallet.writeContract` call per chain, issued in parallel via `Promise.allSettled`.
* **`sponsorGas: true`**: the publisher wallet is a Compose-managed Privy wallet whose transactions are gas-sponsored by Goldsky. No ETH needed on the publisher ever.
* **`context.fetch`**: retries the custodian call with exponential backoff before surfacing a failure.
* **Ripcord pattern**: the data source itself carries a boolean kill-switch the operator can flip out-of-band. Useful when the upstream has a known issue and you want the oracle to pause without a redeploy.
## Step 3: Understand the contract
`ReserveAggregator.sol` is a single-operator, `AggregatorV3Interface`-compatible publisher. The full bundle is stored in one struct; the scalar `totalNav` is exposed via the standard Chainlink reader so existing consumers work unchanged:
```solidity theme={"dark"}
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer, // totalNav scaled to 18 decimals
uint256 startedAt, // asOf from the bundle
uint256 updatedAt,
uint80 answeredInRound
);
function latestBundle() external view returns (NavBundle memory);
function updateNav(
uint256 cash,
uint256 tbills,
uint256 repo,
uint256 totalNav,
uint64 asOf
) external; // onlyPublisher
```
Only the `publisher` address set in the constructor can call `updateNav`. That address is your Compose-managed wallet.
## Step 4: Pre-create the publisher wallet
Compose's wallet-create command provisions the named wallet in the cloud and prints its address, so you can pass that address as the `publisher` constructor argument before you deploy the contracts:
```bash theme={"dark"}
goldsky compose wallet create nav-oracle-publisher --env cloud
```
The command prints the wallet address to stdout. Save it for the next step.
## Step 5: Deploy `ReserveAggregator` on both chains
Deploy to Base Sepolia:
```bash theme={"dark"}
forge create contracts/ReserveAggregator.sol:ReserveAggregator \
--rpc-url https://sepolia.base.org \
--private-key $PRIVATE_KEY \
--broadcast --root . \
--constructor-args 0xYOUR_PUBLISHER_ADDRESS "Example RWA Fund I NAV / USD"
```
And Arbitrum Sepolia:
```bash theme={"dark"}
forge create contracts/ReserveAggregator.sol:ReserveAggregator \
--rpc-url https://sepolia-rollup.arbitrum.io/rpc \
--private-key $PRIVATE_KEY \
--broadcast --root . \
--constructor-args 0xYOUR_PUBLISHER_ADDRESS "Example RWA Fund I NAV / USD"
```
Record both deployed addresses.
`--broadcast` must come *before* `--constructor-args`: forge treats `--constructor-args` as variadic, so any flag that follows it gets consumed as another positional argument and the transaction is never sent.
## Step 6: Wire in the addresses
Open `src/tasks/nav-oracle.ts` and replace the two address constants near the top with the ones you just deployed:
```typescript theme={"dark"}
const BASE_SEPOLIA_AGGREGATOR = "0x..."; // from step 5
const ARBITRUM_SEPOLIA_AGGREGATOR = "0x..."; // from step 5
```
## Step 7: Deploy to Goldsky
```bash theme={"dark"}
goldsky compose deploy
```
The task fires on the next 5-minute boundary. Watch it:
```bash theme={"dark"}
goldsky compose logs
```
You should see a line like:
```text theme={"dark"}
Published Example RWA Fund I NAV=$50,825,000 — base:ok, arb:ok
```
Verify on-chain by reading back `latestRoundData()`:
```bash theme={"dark"}
cast call --rpc-url https://sepolia.base.org 0xYOUR_BASE_ADDRESS \
"latestRoundData()(uint80,int256,uint256,uint256,uint80)"
```
The `answer` field is the total NAV scaled to 18 decimals; `updatedAt` is the custodian's `asOf` timestamp.
## Customization
### Swap the data source
Change `CUSTODIAN_URL` to your own endpoint. Your API must return:
```json theme={"dark"}
{
"accountName": "Your Fund",
"asOf": "2026-04-22T14:00:00Z",
"cash": 125000.00,
"tbills": 42500000.00,
"repo": 8200000.00,
"totalNav": 50825000.00,
"ripcord": false
}
```
Amounts are human-readable USD. The task scales to 18 decimals before writing on-chain.
### Add or swap chains
Add another `wallet.writeContract(...)` inside the `Promise.allSettled` block, targeting a different `evm.chains.` and contract address:
```typescript theme={"dark"}
wallet.writeContract(evm.chains.optimismSepolia, OP_SEPOLIA_AGGREGATOR, signature, args),
```
Deploy a matching `ReserveAggregator` to that chain first.
### Change the publish cadence
Real Proof-of-Reserves / NAV feeds typically publish hourly or daily. Change the cron expression in `compose.yaml`:
```yaml theme={"dark"}
triggers:
- type: "cron"
expression: "0 * * * *" # every hour
```
### Use the ripcord
Any host can flip the kill-switch by returning `"ripcord": true` from the custodian endpoint. The next task run logs `Ripcord engaged …` and skips the publish without erroring, so Compose's retry logic is not triggered. Flip it back to `false` and publishing resumes on the following cycle.
### Rotate the publisher
If you need to re-create the Compose wallet or move to a different key, call `setPublisher(newAddress)` from the current publisher. The old wallet loses `updateNav` permissions; only the new one can publish.
## Resources
* [Compose introduction](/compose/introduction)
* [Task triggers](/compose/task-triggers)
* [EVM wallets & gas sponsoring](/compose/context/evm/wallets)
* [Chainlink `AggregatorV3Interface` reference](https://docs.chain.link/data-feeds/api-reference#aggregatorv3interface)
* [GitHub repository](https://github.com/goldsky-io/documentation-examples/tree/main/compose/nav-oracle)
# Build a Polymarket copy-trader
Source: https://docs.goldsky.com/compose/guides/build-a-polymarket-copy-trader
Mirror Polymarket wallets' trades automatically using Compose and Turbo with a webhook pipeline
This guide walks you through building a Polymarket copy-trading bot. A Turbo pipeline decodes on-chain `OrderFilled` events, filters them to a configurable set of wallets, and webhooks each fill into a Compose app that signs and submits the same trade to the Polymarket CLOB. Winning shares auto-redeem on a 5-minute cron.
It demonstrates the Turbo → Compose webhook pattern, cron triggers, sponsored-gas wallets, `ctx.fetch` for external APIs, and collection-based state.
The example targets [Polymarket V2](https://docs.polymarket.com/v2-migration) (cutover 2026-04-28). V2 introduced new Exchange contracts on Polygon, switched collateral from USDC.e to **pUSD** (a 1:1 ERC-20 backed by USDC.e), and ships a new SDK at `@polymarket/clob-client-v2`. Funding still happens in USDC.e. The `setup_approvals` task wraps it into pUSD via the Collateral Onramp.
## How it works
```mermaid theme={"dark"}
flowchart LR
A[Polygon on-chain] -->|"OrderFilled events"| B[Turbo Pipeline]
B -->|"decode + filter to watched wallets"| B
B -->|"webhook per fill"| C[Compose: copy_trade]
C -->|"sign + POST order"| D[Fly.io Proxy]
D -->|"forward to CLOB"| E[Polymarket CLOB]
F[Cron every 5m] --> G[Compose: redeem]
G -->|"redeemPositions"| H[ConditionalTokens contract]
```
1. **Polygon** emits `OrderFilled` from the V2 CTF Exchange (`0xE111…996B`) and V2 NegRisk Exchange (`0xe222…0F59`) contracts
2. **Turbo pipeline** decodes fills, keeps only trades where maker or taker is in your watched list, and posts each to a Compose HTTP task
3. **`copy_trade`** parses the fill, checks the wallet's pUSD balance, looks up market metadata, signs a V2 FAK (Fill-and-Kill) order, and submits it via the Fly.io proxy (Polymarket's CLOB is geo-blocked from US hosts)
4. **`redeem`** runs every 5 minutes, polls Polymarket's data API for redeemable positions, and calls `redeemPositions` on-chain
## Prerequisites
* [Goldsky CLI installed](/installation)
* A Compose API token from your Goldsky project (for the webhook auth secret)
* An EOA private key for the bot's wallet (no Polymarket UI onboarding or proxy wallet required)
* USDC.e (`0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174`) on Polygon to fund the bot (the `setup_approvals` task wraps it into pUSD before trading)
* A list of wallets you want to mirror (selecting them is out of scope for this guide)
## Project structure
```text theme={"dark"}
copy-trader/
├── compose.yaml # Compose app + env config
├── tsconfig.json # TypeScript config
├── package.json # npm deps (bundled by Compose CLI)
├── pipeline/
│ └── polymarket-ctf-events.yaml # Turbo pipeline → webhook sink
└── src/
├── lib/
│ ├── clob.ts # Polymarket CLOB client
│ ├── gamma.ts # Market metadata lookups
│ └── types.ts # Contract addresses + types
└── tasks/
├── copy_trade.ts # HTTP: mirror a fill
├── redeem.ts # Cron: redeem winning shares
└── setup_approvals.ts # HTTP: one-time approvals
```
## Step 1: Set up the project
Clone the example repository and install dependencies:
```bash theme={"dark"}
git clone https://github.com/goldsky-io/documentation-examples.git
cd documentation-examples/compose/copy-trader
npm install
```
The Compose CLI bundles tasks with esbuild against `node_modules/`, so `npm install` is required before `goldsky compose start` or `deploy`.
## Step 2: Pick wallets to copy and update both configs
The pipeline pre-filters on-chain events to the watched list, so the same addresses must appear in two places.
In `compose.yaml`:
```yaml theme={"dark"}
env:
cloud:
WATCHED_WALLETS: "0xwhale1,0xwhale2"
```
In `pipeline/polymarket-ctf-events.yaml`, update the `watched_fills` transform:
```yaml theme={"dark"}
watched_fills:
type: sql
primary_key: id
sql: |
SELECT * FROM order_fills
WHERE maker IN (
'0xwhale1',
'0xwhale2'
)
OR taker IN (
'0xwhale1',
'0xwhale2'
)
```
## Step 3: Set the wallet private key
The Compose app signs CLOB orders as an EOA. No Polymarket proxy wallet is involved:
```bash theme={"dark"}
goldsky compose secret set PRIVATE_KEY --value "0x..."
```
## Step 4: Create the webhook auth secret
The Turbo webhook authenticates to your Compose app with a Goldsky-level secret. This is a one-time setup per project:
```bash theme={"dark"}
goldsky secret create --name COMPOSE_WEBHOOK_AUTH \
--value '{"type": "httpauth", "secretKey": "Authorization", "secretValue": "Bearer YOUR_COMPOSE_API_TOKEN"}'
```
The pipeline references this secret by name in its webhook sink, so every pipeline in the project can reuse it.
## Step 5: Deploy the app and pipeline
```bash theme={"dark"}
goldsky compose deploy
goldsky turbo apply pipeline/polymarket-ctf-events.yaml
```
The pipeline starts at the latest Polygon block, so fills produced before you deployed will not be backfilled.
## Step 6: Fund the wallet
Send USDC.e to the EOA that corresponds to the private key from step 3. Compose sponsors gas on all on-chain calls, so you do not need MATIC in the wallet.
## Step 7: Grant approvals and wrap collateral
V2 markets settle in pUSD, so the bot needs to (a) approve the Collateral Onramp to spend USDC.e, (b) wrap the wallet's USDC.e balance into pUSD, and (c) approve pUSD + ConditionalTokens to both V2 Exchanges. The `setup_approvals` task does all of this in one call. Compose sponsors every transaction:
```bash theme={"dark"}
curl -X POST -H "Authorization: Bearer $COMPOSE_TOKEN" \
https://api.goldsky.com/api/admin/compose/v1/copy-trader/tasks/setup_approvals
```
The task is idempotent: re-call it after every USDC.e top-up to wrap the new balance. Approvals are max-allowance, so re-approving is a cheap no-op.
The bot begins trading as soon as the next fill on a watched wallet lands in the pipeline.
## Understanding the code
### Parsing a fill
V2's `OrderFilled` event encodes the maker's side as a `uint8` (`0 = BUY`, `1 = SELL`) and exposes a single `tokenId` instead of the V1 maker/taker asset-id pair. The whale we want to copy can be the maker or the taker (the taker takes the opposite side):
```typescript theme={"dark"}
function parseFill(
row: OrderFillRow,
watchedWallets: Set
): { side: "BUY" | "SELL"; tokenId: string; whalePrice: number } {
const makerIsWhale = watchedWallets.has(row.maker.toLowerCase());
const takerIsWhale = watchedWallets.has(row.taker.toLowerCase());
// Maker's side as encoded in the event: "0" = BUY, "1" = SELL.
const makerSide: "BUY" | "SELL" = row.side === "0" ? "BUY" : "SELL";
const oppositeSide: "BUY" | "SELL" = makerSide === "BUY" ? "SELL" : "BUY";
const whaleSide = makerIsWhale ? makerSide : oppositeSide;
// Price = pUSD per share. Layout depends on the maker's side.
// makerSide = BUY: makerAmount = pUSD, takerAmount = shares
// makerSide = SELL: makerAmount = shares, takerAmount = pUSD
const usdcAmount = makerSide === "BUY" ? row.maker_amount : row.taker_amount;
const sharesAmount = makerSide === "BUY" ? row.taker_amount : row.maker_amount;
const price = sharesAmount > 0 ? usdcAmount / sharesAmount : 0;
return {
side: whaleSide,
tokenId: row.token_id,
whalePrice: price,
};
}
```
### On-chain balance as source of truth
Before every BUY, the task reads pUSD balance directly from Polygon rather than keeping a local counter. pUSD has 6 decimals (matching USDC.e):
```typescript theme={"dark"}
const balResp = (await ctx.fetch("https://polygon-bor-rpc.publicnode.com", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({
jsonrpc: "2.0",
method: "eth_call",
params: [
{
to: "0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB", // pUSD
data: "0x70a08231000000000000000000000000" + address.slice(2).toLowerCase(),
},
"latest",
],
id: 1,
}),
})) as { result?: string };
const pusdBalance = balResp?.result ? Number(BigInt(balResp.result)) / 1e6 : 0;
if (pusdBalance < 1.1) {
return { status: "BALANCE_LOW", balance: pusdBalance };
}
```
A local budget collection would drift out of sync with the real wallet after redemptions, unsponsored gas, or manual top-ups. Reading the chain avoids that entirely.
### Signing and submitting via `ctx.fetch`
Polymarket's `@polymarket/clob-client-v2` SDK uses axios for HTTP, which fails under Compose's task runtime because task binaries run without `--allow-net`. The template reuses the SDK's pure signing utilities (local crypto only) and routes every HTTP call through `ctx.fetch`. The `version: 2` argument selects the V2 Exchange domain and order struct (V2 fees are computed on-chain, so they are no longer signed):
```typescript theme={"dark"}
import {
OrderBuilder,
Side,
OrderType,
SignatureTypeV2,
createL2Headers,
orderToJsonV2,
} from "@polymarket/clob-client-v2";
const builder = new OrderBuilder(wallet, 137, SignatureTypeV2.EOA);
// Build + sign locally (no HTTP)
const signedOrder = await builder.buildMarketOrder(
{ tokenID, price, amount, side: Side.BUY },
{ tickSize, negRisk },
2 // V2 order version
);
// Submit through ctx.fetch → Fly proxy → CLOB
const body = orderToJsonV2(signedOrder, creds.key, OrderType.FAK);
const bodyStr = JSON.stringify(body);
const l2Headers = await createL2Headers(wallet, creds, {
method: "POST",
requestPath: "/order",
body: bodyStr,
});
const resp = await ctx.fetch(`${host}/order`, {
method: "POST",
headers: { ...l2Headers, "Content-Type": "application/json" },
body: bodyStr,
});
```
`ctx.fetch` is host-mediated, which means it has network access even though the task itself does not. This is the general pattern for calling external APIs from a Compose task. See [calling external APIs](/compose/context/fetch) for more.
### Why the Fly.io proxy
Polymarket's CLOB API geo-blocks the US. Compose tasks run from `us-west`. The template points `CLOB_HOST` at a shared Goldsky-hosted Fly.io proxy in Amsterdam that forwards every request from an EU IP. If you want to isolate yourself from the shared proxy, deploy your own copy of [`fly-polymarket-proxy`](https://github.com/goldsky-io/fly-polymarket-proxy) and update `CLOB_HOST` in `compose.yaml`.
## Key Compose features used
* **Turbo → Compose webhook pattern**: a pipeline sinks decoded on-chain events directly to an HTTP task via a `COMPOSE_WEBHOOK_AUTH` secret
* **`ctx.fetch`**: all outbound HTTP (CLOB, Gamma, Polymarket data API, Polygon RPC) goes through Compose's host-mediated fetch
* **`ctx.evm.wallet` with `sponsorGas: true`**: approvals and redemptions use a Compose-sponsored wallet so the EOA does not need MATIC
* **Cron triggers**: the `redeem` task runs every 5 minutes via `0 */5 * * * *`
* **`ctx.collection`**: `positions` and `trades` collections persist bot state across invocations
* **Compose secrets**: the wallet private key is stored via `goldsky compose secret set`, not baked into the manifest
## Customization
### Trade size
The default is Polymarket's \$1 minimum notional. Raise it in `compose.yaml`:
```yaml theme={"dark"}
TRADE_AMOUNT_USD: "10"
```
### Different markets
The pipeline filters by address only, so it picks up every fill on the CTF Exchange and NegRisk Exchange. To scope to a specific market type (e.g. a particular event's outcomes), add a `token_id` filter to the `watched_fills` transform.
### Your own proxy
`CLOB_HOST` defaults to the Goldsky-hosted Fly proxy. To isolate from it, deploy [`fly-polymarket-proxy`](https://github.com/goldsky-io/fly-polymarket-proxy) yourself and point `CLOB_HOST` at your deployment.
## Resources
* [Compose introduction](/compose/introduction)
* [Turbo introduction](/turbo-pipelines/introduction)
* [Task triggers](/compose/task-triggers)
* [Calling external APIs](/compose/context/fetch)
* [Collections](/compose/context/collections)
* [Secrets](/compose/secrets)
* [GitHub repository](https://github.com/goldsky-io/documentation-examples/tree/main/compose/copy-trader)
# Build a binary prediction market
Source: https://docs.goldsky.com/compose/guides/build-a-prediction-market
Build a binary prediction market on Gnosis ConditionalTokens using Compose, CoinGecko, and multi-task orchestration
This guide walks you through building a self-contained binary prediction market on [Gnosis ConditionalTokens (CTF)](https://docs.gnosis.io/conditionaltokens/). A single cron orchestrator runs every 5 minutes, fetches the current BTC/USD price, resolves the previous cycle's market, and prepares a new one for the next 5-minute bucket. It demonstrates multi-task orchestration, `callTask` fan-out, Compose-managed wallets as on-chain oracles, and idempotent chain writes.
## How it works
```mermaid theme={"dark"}
flowchart LR
A[Cron Trigger] -->|"every 5 min"| B[orchestrator]
B -->|callTask| C[market_data]
C -->|"BTC/USD price"| D[CoinGecko API]
B -->|callTask| E[launch_market]
B -->|callTask| F[resolve_market]
E -->|prepareCondition| G[Gnosis CTF on Base Sepolia]
F -->|reportPayouts| G
B -->|"persist state"| H[Collection]
```
Each 5-minute cycle:
1. **`market_data`** fetches the current BTC/USD price from CoinGecko.
2. **`resolve_market`** reports payouts for any market whose `endTime` has passed. Outcome is `[1, 0]` (UP) if the current price is at or above the market's `openPrice`, else `[0, 1]` (DOWN).
3. **`launch_market`** prepares a new condition on the CTF for the current 5-minute bucket, using the same fetched price as the new market's `openPrice`.
One price fetch per cycle serves both purposes: the closing tick of the expiring market sits at the same moment as the opening tick of the new one.
## Prerequisites
* [Goldsky CLI installed](/installation)
## Project structure
```text theme={"dark"}
prediction-market/
├── compose.yaml # 1 cron + 4 callable tasks
├── package.json # viem dependency
├── tsconfig.json # Compose path alias
├── src/
│ ├── lib/
│ │ ├── constants.ts # Chain, CTF address, wallet name, salt
│ │ ├── types.ts # Market type
│ │ └── utils.ts # questionId derivation, wallet helper
│ └── tasks/
│ ├── orchestrator.ts # Cron: fetch → resolve → launch
│ ├── market-data.ts # HTTP: CoinGecko
│ ├── launch-market.ts # Chain: prepareCondition
│ ├── resolve-market.ts # Chain: reportPayouts
│ └── generate-wallet.ts # HTTP: returns oracle address
```
## Step 1: Set up the project
Clone the example repository:
```bash theme={"dark"}
git clone https://github.com/goldsky-io/documentation-examples.git
cd documentation-examples/compose/prediction-market
npm install
```
## Step 2: Understand the orchestrator
`orchestrator.ts` is the only task with a cron trigger. It fans out to the three worker tasks via `context.callTask`:
```typescript theme={"dark"}
import type { TaskContext } from "compose";
import { ASSET_PAIR, DURATION_SEC } from "../lib/constants";
import type { Market } from "../lib/types";
import { computeQuestionId, floorToMarketStart } from "../lib/utils";
import type { TaskPayload as LaunchPayload } from "./launch-market";
import type { TaskPayload as ResolvePayload } from "./resolve-market";
import type { ResponsePayload as PriceData } from "./market-data";
export async function main(context: TaskContext) {
const { collection, callTask } = context;
const nowMs = Date.now();
const currentMarketStart = floorToMarketStart(nowMs);
const markets = await collection("markets", [
{ path: "endTime", type: "numeric" },
{ path: "resolved", type: "boolean" },
]);
// One HTTP hit — used for BOTH the closePrice of the expiring market
// AND the openPrice of the new one (same 5-min boundary).
const { priceUsd } = await callTask