Index of every page on this site: llms.txt
All skills
austintgriffith avatar

/orchestration

@47779e7
Run it yourself

Use when a Scaffold-ETH 2 build leaves localhost: planning the launch order, deploying and verifying contracts on a live network, standing up a fork of a real chain to rehearse a deploy, or fixing a contract bug that is already onchain. Not for running the app or a demo against that fork (`/frontend-playbook`).

Use this Skill: https://skilld.dev/gh/austintgriffith/ethskills/orchestration

Nothing lands on disk. Nothing to clean up.

Fork this Skill

Edit a local copy. It keeps the author and licence.

SKILL.md

≈82 tokens for metadata: the name and description. ≈1.3k when used: this file.

Description uses 4.1% of example budget

Before choosing a Skill, your Agent reads its name and description. All available Skills share that space.

  • A shorter description leaves more room for other Skills. This entry exceeds our 1% size suggestion.

In our Claude Code example, all Skill names and descriptions share 8,000 characters. This Skill uses ≈328 characters, or 4.1%.

The 1% threshold is a size suggestion. Longer descriptions can still fit.

Your model, settings, and other Skills decide how much text your Agent can read.

Example settings and source

The example uses a 200k-token context and default Claude Code settings. The count includes the name, description, separators, and when_to_use when present. Codex also counts local file paths.

Skit's source and limits: Codex 0.160.1, Claude Code 2.1.292.

Shipping a dApp

Going live is three moves, never one: contracts local, then contracts live with the frontend still on localhost, then the frontend public. The middle move is the one that gets skipped and the one that catches everything — real chain, real gas, real decimals, a real wallet — while the UI is still yours alone to edit in seconds.

Name a go/no-go condition at each boundary, not just the commands. Three of them:

  • Before deploying to the live network: contract tests pass, the deploy script runs clean against a local fork, and there is a funded deployer — yarn generate creates one (Foundry: an encrypted keystore in ~/.foundry/keystores; Hardhat: an encrypted key in packages/hardhat/.env), yarn account prints its address and its balance on each chain, and it needs real ETH on the target chain before the deploy, not after it fails.
  • Before the frontend is reachable publicly: you have walked the entire user journey against the live contracts with a real wallet and real money — $1-10 of your own — and every step worked.
  • After the frontend deploy: you have loaded the public URL yourself and put one transaction through it.

A runbook that names the commands but not the conditions will keep going after something has already gone wrong.

Verify in the same breath as deploy

yarn verify --network base (or your target chain) belongs immediately after yarn deploy --network base, not in a launch checklist weeks out. Until it runs, users and integrators are looking at opaque bytecode, and you are debugging a live contract without source on the explorer.

Nobody has to go and get a block explorer API key first. packages/foundry/.env.example already carries a working ETHERSCAN_API_KEY and postinstall copies it to .env, so yarn verify works on a fresh checkout. So a launch plan never lists "obtain an explorer key" among its steps, and never hands anyone an env template with a blank ETHERSCAN_API_KEY= to fill in: the value is already there, and a step that waits on that key waits for nothing. Swapping in your own is optional housekeeping afterwards, not a launch dependency. One real constraint: yarn verify replays broadcast/run-latest.json, so run it from the checkout that did the deploy.

A live contract bug goes back to the start

Deployed bytecode cannot be edited, and the contract is a public API — a guard added in the frontend binds nobody, because direct calls, integrators and other frontends reach the same function. Shipping the UI clamp to buy hours is fine; calling it the fix is not.

The fix is the whole loop, in order: reproduce locally, correct the source, add the regression test that fails without the correction, redeploy (or upgrade in place, if it is behind a proxy), repoint the frontend if the address moved, and handle the state and users already there — migration or comms, your call. The loop is the same whether the bug surfaces before launch or with the app already public.

SE-2 specifics worth having right

  • Fork the chain you are targeting rather than yarn chain — yarn fork --network base gives you Uniswap, USDC, Aave and funded whales already deployed, so you write no mocks of things that exist. Two tokens, and that is the whole rule: yarn binds the first token after the script name to $0, whatever it looks like, so the script's $1 is only set if you pass something before the value. yarn fork base and yarn fork --network=base both leave $1 empty and silently fork Ethereum mainnet; yarn fork --network base, yarn fork -n base and yarn fork -- base all work. In the hardhat flavor yarn fork takes no network argument (passing one errors) and always forks mainnet — change forking.url in hardhat.config.ts to fork anything else. Either way the fork answers chain id 31337, so the chain id never tells you what you forked: check for state only the target chain has, such as code at one of its token addresses.
  • scaffold.config.ts is committed. An RPC or API key pasted into rpcOverrides or alchemyApiKey is a published key; read it from process.env and keep the value in .env.local. wallets/SKILL.md covers the rest of key handling.
  • The frontend goes to the live chain only when you say so. scaffold.config.ts targetNetworks still names the local chain after the contracts are live, and a frontend built before that switch reads a chain nobody is on. Change it in the same step that repoints the frontend at the deployed addresses, and not before — during fork work it belongs on the local chain (chains.foundry, or chains.hardhat in the Hardhat flavor), since the fork answers 31337 whatever it forked (frontend-playbook has the detail).
  • The burner wallet stays local. burnerWalletMode in scaffold.config.ts defaults to "localNetworksOnly". On a live chain "allNetworks" gives users a key stored in localStorage; keep the default for production.
  • A frontend-only ticket deploys nothing. Do not stand up a chain and redeploy to regenerate deployedContracts.ts unless deploying was the ask.

Source: SKILL.md on GitHub

skilld matched fixed text patterns in SKILL.md and file names. Patterns miss obfuscated code.

skilld run checks every file with the same patterns. It asks for approval before it loads a Skill with a behavior marked Needs approval.

No alerts21d4 checks · Risk SAFE
  • Gen Agent Trust Hub21d

    This skill provides instructional guidance for deploying and orchestrating dApps using Scaffold-ETH 2. It covers best practices for contract verification, network management, and secure handling of credentials using environment variables.

  • Socket21d

    No alerts

  • Snyk21d

    Risk: LOW · No issues

  • Runlayer8mo

    1/1 file flagged

Signed by skilld at 47779e7. This ties the file your Agent reads to that commit on GitHub. It does not review the instructions.

Last checked against GitHub 4 weeks ago.

Activeupdated 4 weeks ago

README badge

README badge for austintgriffith/ethskills/orchestration