Deploy on Gully Chain

One page with everything a team needs to ship on Gully Chain Testnet without asking us first. The same data is machine-readable: /chain.json (wallet and chain-list parameters) and /addresses.json (every contract below, with its status).

#Network

#Machine-readable files

// add the network from a dapp, straight from chain.json
const chain = await (await fetch("https://docs.gullychain.xyz/chain.json")).json();
await window.ethereum.request({ method: "wallet_addEthereumChain", params: [chain.eip3085] });

Both files are CORS-open and regenerated from the deploy records every time the docs are built.

#Get test ETH

• Faucet: faucet.gullychain.xyz. Sign in with Gully ID, pass the captcha, claim. Enough for several deploys.
• More than the faucet gives: bridge Sepolia ETH in through bridge.gullychain.xyz (Arbitrum Sepolia faucets are listed on Bridging), or email [email protected] with your Gully ID and what you are building: verified developer accounts get a larger faucet allowance.

#Foundry

foundry.toml:

[profile.default]
solc = "0.8.28"
evm_version = "cancun"
optimizer = true
optimizer_runs = 200

[rpc_endpoints]
gully = "https://rpc.gullychain.xyz"
gully_alt = "https://testnet-rpc.gullychain.xyz"

Deploy and verify in one command:

forge create src/Counter.sol:Counter \
  --rpc-url gully \
  --private-key $PRIVATE_KEY \
  --broadcast \
  --verify --verifier sourcify --verifier-url https://verify.gullychain.xyz/

With a script (salted CREATE2 deploys go through the Arachnid factory, so they land at the same address as on other chains):

forge script script/Deploy.s.sol --rpc-url gully --broadcast \
  --verify --verifier sourcify --verifier-url https://verify.gullychain.xyz/

Verify a contract that is already deployed (no API key, no constructor arguments: Sourcify reads them from the creation transaction):

forge verify-contract <address> src/Counter.sol:Counter \
  --chain-id 485590 \
  --rpc-url https://rpc.gullychain.xyz \
  --verifier sourcify \
  --verifier-url https://verify.gullychain.xyz/ \
  --watch

Use a current Foundry (foundryup): the server speaks the Sourcify API v2 only. Check a result with curl https://verify.gullychain.xyz/v2/contract/485590/<address>. More, including Windows path issues and the web form: Verify your contract.

#Hardhat

// hardhat.config.ts (network part; the verify plugin settings are on /verify/#hardhat)
export default {
  solidity: { version: "0.8.28", settings: { evmVersion: "cancun", optimizer: { enabled: true, runs: 200 } } },
  networks: {
    gully: { url: "https://rpc.gullychain.xyz", chainId: 485590, accounts: [process.env.PRIVATE_KEY!] },
  },
};

npx hardhat run scripts/deploy.ts --network gully
npx hardhat verify --network gully <address>

Verification needs a Sourcify v2 capable plugin: see Verify your contract. Any Hardhat version can upload artifacts/build-info/*.json on verify.gullychain.xyz.

#viem

import { createPublicClient, createWalletClient, defineChain, fallback, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";

export const gullyTestnet = defineChain({
  id: 485590,
  name: "Gully Chain Testnet",
  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.gullychain.xyz", "https://testnet-rpc.gullychain.xyz"] } },
  blockExplorers: { default: { name: "Gully Explorer", url: "https://testnet-explorer.gullychain.xyz" } },
  contracts: { multicall3: { address: "0xcA11bde05977b3631167028862bE2a173976CA11" } },
});

const transport = fallback(gullyTestnet.rpcUrls.default.http.map((url) => http(url)), { rank: false });
export const publicClient = createPublicClient({ chain: gullyTestnet, transport });
export const walletClient = createWalletClient({ chain: gullyTestnet, transport, account: privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`) });

// deploy: const hash = await walletClient.deployContract({ abi, bytecode, args: [] });

The full four-endpoint fallback list is on Network reference.

#ethers v6

import { ContractFactory, JsonRpcProvider, Network, Wallet } from "ethers";

const network = Network.from(485590);
const provider = new JsonRpcProvider("https://rpc.gullychain.xyz", network, { staticNetwork: network });
const wallet = new Wallet(process.env.PRIVATE_KEY!, provider);

const contract = await new ContractFactory(abi, bytecode, wallet).deploy();
await contract.waitForDeployment();
console.log(await contract.getAddress());

A FallbackProvider over every endpoint: Network reference.

#Standard contracts

The contracts that tooling expects at the same address on every chain. Status is the result of an eth_getCode check at that address; the status page (opens in a new tab) re-checks every one of them each minute (group "Chain readiness").

#Deterministic deployers

#Utilities

#ERC-4337

#Safe 1.4.1

#NFT marketplaces

The canonical Safe 1.4.1 addresses stay empty until the Safe team deploys their singleton factory on Gully Chain (it needs Safe's own key). The same audited creation code is live at Gully's addresses, shown in the Status column; pass them to Safe tooling explicitly (see Gully Safe).

#Gully contracts

Gully Chain's own deployments: tokens, Uniswap v3, the oracle, names, the testnet launchpad, accounts, the token bridge and the Hyperlane routes. Everything else (Quests, Pay, Sentry, RWA rails, Offerwall) is on Contract addresses.

#Tokens

#Uniswap v3

#Oracle (testnet only)

#.gully names

#Launchpad

#Smart accounts

#Gully Safe

#Token bridge (Gully Chain side)

#Apps

#Hyperlane

#On Arbitrum Sepolia

#Rollup core (Arbitrum Sepolia)

#Token bridge (Arbitrum Sepolia side)

#Quirks

• Blocks only when there are transactions. No fixed block time; a quiet chain can go minutes without a block. Do not use new blocks as a clock or a health check.
• Gas includes the parent-chain data cost. Always estimate (eth_estimateGas; Foundry, Hardhat, viem and ethers do it by default). Never hard-code gas limits copied from Ethereum.
• Cancun EVM (PUSH0, MCOPY, transient storage). Set evm_version = "cancun" or older. Max contract size 24,576 bytes, init code 49,152 bytes.
• Stylus: contracts in Rust, C and C++ run next to Solidity. See Stylus.
• Keyless pre-EIP-155 transactions are accepted, so published deterministic deployers (Arachnid, ERC-1820, Multicall3, CreateX) can be replayed. Your own transactions should still be EIP-155 signed (every tool does this by default).
• Arbitrum precompiles are available: ArbSys at 0x64, ArbGasInfo at 0x6c, ArbWasm at 0x71.
• No debug_* / trace_* on the public RPCs.

#Rate limits

• Send single JSON-RPC requests. Batches work but count per call and are the first thing to hit a limit; keep them small.
• Over the limit you get HTTP 429 or a JSON-RPC rate-limit error: back off and retry, or move to the next endpoint.
• Never send the same signed transaction to two endpoints in parallel. Retrying it on the next endpoint after a failure is fine.

#WebSocket

There is no public WebSocket RPC yet: eth_subscribe is not available on the public endpoints. viem's watchBlocks, watchContractEvent and ethers' provider.on(...) fall back to HTTPS polling, which works on every endpoint above. A wss://rpc.gullychain.xyz/ws endpoint is prepared and will be listed here, in /chain.json and on the status page (opens in a new tab) when it is live.

#Get help

• Email [email protected]: bugs, higher RPC limits, a bigger faucet allowance, a contract you need deployed.
• Discord GullyChain (opens in a new tab) and Telegram t.me/GullyChain (opens in a new tab) (news) and t.me/GullyChainDeploys (opens in a new tab) (new deploys).
• Is something down? Check status.gullylabs.xyz (opens in a new tab) first. What to include in a report: Support.