Deploy to Gora

Deploy and invoke a Gora app on the live public testnet, end to end, with the gora CLI.

Deploy to Gora

The fastest way to ship a Gora app is the live public testnet. No signup and no local infrastructure — install the CLI, set a developer token, point it at the endpoint, and deploy. Deploying and invoking are free (no GORA cost), but the public testnet requires a developer token that is your identity.

For endpoints, deployed contract IDs, and what the testnet supports today, see Connect to the testnet.

Prerequisites

• the gora CLI — install it with:

  curl -fsSL https://gora-bridge.74.241.248.103.nip.io/install.sh | sh
  

  This adds gora to ~/.gora/bin (make sure that directory is on your PATH). The installer fetches a prebuilt tarball for macOS/Linux on arm64/x86_64 from the testnet mirror (/releases/latest/) or from the GitHub release; with neither available it prints the source-build fallback.

• a developer token you choose — it is your identity on the testnet (set in step 1). No GORA and no signup are needed to deploy or invoke.

1. Point the CLI at the testnet

One hostname serves both the node API (under /v1/*) and the dev bridge routes:

https://gora-bridge.74.241.248.103.nip.io

Save it once per app folder:

gora config set node.url https://gora-bridge.74.241.248.103.nip.io

Or export it for every command:

export GORA_NODE_URL=https://gora-bridge.74.241.248.103.nip.io

Or pass --node <url> on individual commands. Check the endpoint is up:

curl https://gora-bridge.74.241.248.103.nip.io/health
curl https://gora-bridge.74.241.248.103.nip.io/v1/apps

Set your developer token — on the public testnet this is required and it is your identity: the first token to claim an app id owns it, so no one else can overwrite your app, schedule it, or delete its schedules. Every request you send runs with caller set to your token’s dev_… identity.

gora config set api.token <any-string-you-choose>

Keep it secret and reuse the same token across your projects so you keep owning your apps. Details: Connect to the testnet.

2. Create and build an app

gora init hello-alice        # pick a unique name — app ids are global on the shared testnet
cd hello-alice
gora build
gora validate
gora package

Validation catches missing artifacts, invalid JSON, unknown execution modes, missing policies, and obvious secrets. Packaging writes a deterministic receipt to:

.gora/package/package.json

Note: dashes in app names become underscores in the app id — hello-alice deploys as hello_alice.

3. Deploy

gora deploy .

Deploy uploads:

• app artifact bytes or source
• manifest JSON
• policy JSON
• deterministic package metadata
• optional contract bindings

The receipt is written to:

.gora/deployments/dev.json

Deploying costs nothing: the testnet node seeds a developer balance for each app, and a simple invoke costs roughly 106 billing units from that balance.

Re-running gora deploy . upgrades the app in place — same app_id, new version.

4. Invoke

gora invoke --app hello_alice --input fixtures/request.json

Invocations are synchronous: the response is the app’s result (output, billing settlement, state roots). Without a saved node.url, add --node https://gora-bridge.74.241.248.103.nip.io.

5. Inspect

gora inspect result <request-id>
gora inspect request <request-id>
gora inspect attestation <request-id>
gora inspect app hello_alice

Inspect outputs are saved under:

.gora/inspect/

On-chain apps: link contract metadata before deploy

Only Algorand testnet is live for contract flows today (gateway app 767488273, staking 764254589, GORA ASA 764254575, algod https://testnet-api.algonode.cloud). Base and Solana are not yet deployed on the public testnet. Full IDs and endpoints: Connect to the testnet.

If your app targets a chain gateway or app contract, link that metadata before deploy:

gora contract doctor --chain algorand
gora contract build --chain algorand
gora contract deploy --chain algorand
gora contract link --chain algorand

This writes local metadata under:

.gora/contracts/<chain>/latest.json

and updates gora.app.json with a contract binding. Skip this step for off-chain-only apps.

Node API reference

All routes live behind the public URL:

Method	Route	Purpose
GET	/health	Endpoint health and route list
GET	/v1/apps	List registered apps
GET	/v1/apps/{id}	App details
DELETE	/v1/apps/{id}	Delete your app: registry, state, schedules, history (gora app delete <id>); the id is free again
GET	/v1/apps/{id}/state	App state (executes the app in state mode; needs a token on the public testnet)
POST	/v1/apps/deploy	Deploy an app package
POST	/v1/requests	Submit a request
GET	/v1/requests/{id}	Request status (the node keeps the newest 500 records per app, 5,000 overall)
GET	/v1/requests/{id}/result	Request result
GET	/v1/requests/{id}/attestation	Committee-signed attestation
GET/POST	/v1/schedules	List your schedules / create one (only the app’s owner can schedule an app)
DELETE	/v1/schedules/{id}	Delete one of your schedules (gora schedule delete --schedule-id <id>)
POST	/v1/schedules/run-due	Run due schedules
GET	/v1/contracts	Contract metadata, all chains
GET	/v1/contracts/{chain}	Contract metadata for one chain

Limits: artifacts up to 5 MiB, request bodies up to 8 MiB.

What deploy does not do

gora deploy does not:

• deploy smart contracts
• submit chain transactions
• sign with user keys
• pay chain gas

It registers the Gora app package. Chain effects happen later through a gateway, wallet, contract, mobile signing flow, or submitter.

Alternative: run a local node

If you want the full deploy + invoke + inspect loop on your own machine, the dev node is built into the CLI:

gora node serve --http 127.0.0.1:8080 \
  --store ~/gora-node-data/node.json \
  --artifact-root ~/gora-node-data/artifacts

Useful flags:

• --contract-registry <json> — expose chain contract metadata
• --token <bearer> — require Authorization: Bearer on writes; mandatory if you bind anything other than 127.0.0.1
• --signing-request-sink <bridge-url> — forward mobile_signing_request / chain_callback outputs to a Dev Bridge

Then use --node http://127.0.0.1:8080 (or set node.url to it) in the commands above.

Next: Test with mobile.