Build on
Shido Testnet

npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox

require('@nomicfoundation/hardhat-toolbox');
require('dotenv/config');

module.exports = {
  solidity: '0.8.24',
  networks: {
    shidoTestnet: {
      url: 'https://rpc.testnet.shidoscan.net',
      chainId: 9007,
      accounts: [process.env.PRIVATE_KEY]
    }
  }
};

npx hardhat run scripts/deploy.js --network shidoTestnet

curl -L https://foundry.paradigm.xyz | bash && foundryup

forge create --rpc-url https://rpc.testnet.shidoscan.net \
  --private-key $PRIVATE_KEY \
  src/MyContract.sol:MyContract

cast send --rpc-url https://rpc.testnet.shidoscan.net \
  --private-key $PRIVATE_KEY \
  <CONTRACT_ADDRESS> 'transfer(address,uint256)' 0xRecipient 1000

cast call --rpc-url https://rpc.testnet.shidoscan.net \
  <CONTRACT_ADDRESS> 'balanceOf(address)(uint256)' $MY_ADDRESS

npm install ethers

import { ethers } from 'ethers';

// Provider
const provider = new ethers.JsonRpcProvider(
  'https://rpc.testnet.shidoscan.net',
  { chainId: 9007, name: 'shido-testnet' }
);

// Wallet
const wallet = new ethers.Wallet(process.env.PRIVATE_KEY, provider);

// Send SHIDO
const tx = await wallet.sendTransaction({
  to: '0xRecipientAddress',
  value: ethers.parseEther('1.0')
});
await tx.wait();
console.log('Tx hash:', tx.hash);

// Deploy contract
const factory = new ethers.ContractFactory(abi, bytecode, wallet);
const contract = await factory.deploy(...constructorArgs);
await contract.waitForDeployment();
console.log('Deployed at:', await contract.getAddress());

const { Web3 } = require('web3');
const web3 = new Web3('https://rpc.testnet.shidoscan.net');

// Get balance
const balance = await web3.eth.getBalance('0xAddress');
console.log(web3.utils.fromWei(balance, 'ether'), 'SHIDO');

// Send transaction
const receipt = await web3.eth.sendTransaction({
  from: myAddress,
  to: '0xRecipient',
  value: web3.utils.toWei('1', 'ether')
});

// hardhat.config.js — add etherscan config:
etherscan: {
  apiKey: { shidoTestnet: 'any-string' },
  customChains: [{
    network: 'shidoTestnet',
    chainId: 9007,
    urls: {
      apiURL: 'https://testnet.shidoscan.net/api',
      browserURL: 'https://testnet.shidoscan.net'
    }
  }]
}

npx hardhat verify --network shidoTestnet <CONTRACT_ADDRESS> <CONSTRUCTOR_ARGS>

forge verify-contract <CONTRACT_ADDRESS> src/MyContract.sol:MyContract \
  --rpc-url https://rpc.testnet.shidoscan.net \
  --verifier blockscout \
  --verifier-url https://testnet.shidoscan.net/api

curl -X POST https://faucet.testnet.shidoscan.net/api/drip \
  -H "Content-Type: application/json" \
  -d '{"address":"0xYourWalletAddress"}'

{
  "success": true,
  "txHash": "0xabc123...",
  "amount": "1000",
  "explorerUrl": "https://testnet.shidoscan.net/tx/0xabc123..."
}

curl https://faucet.testnet.shidoscan.net/api/check/0xYourAddress

curl https://faucet.testnet.shidoscan.net/api/status

# Trace with callTracer (shows all internal calls)
curl -X POST https://rpc.testnet.shidoscan.net \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "debug_traceTransaction",
    "params": ["0xYOUR_TX_HASH", {"tracer": "callTracer"}],
    "id": 1
  }'

// Trace with ethers.js
const trace = await provider.send("debug_traceTransaction", [
  txHash,
  { tracer: "callTracer" }
]);
console.log(trace.calls); // all internal contract calls

const provider = new ethers.WebSocketProvider('wss://ws.testnet.shidoscan.net');

// Subscribe to new blocks
provider.on('block', (blockNumber) => {
  console.log('New block:', blockNumber);
});

// Subscribe to contract events
const filter = { address: CONTRACT_ADDRESS, topics: [EVENT_TOPIC] };
provider.on(filter, (log) => console.log(log));

// ethers.js v6
const factory = new ethers.Contract(
  '0x1dd3d20FbA378671E5d4f875eB0bF39CC9AE451e',
  ['function createToken(string,string,uint8,uint256) returns (address)'],
  signer
);

// Deploy a 18-decimal token with 1 billion initial supply
const tx        = await factory.createToken('My Token', 'MTK', 18, 1_000_000_000);
const receipt   = await tx.wait();
// Token address is in the TokenCreated event

// Approve router, then swap
const router = new ethers.Contract('0xCB6F539B872ee7b1C071CC4B4086245Bdc6919e5', [
  'function exactInputSingle((address,address,uint24,address,uint256,uint256,uint256,uint160)) payable returns (uint256)'
], signer);

await router.exactInputSingle({
  tokenIn:           WSHIDO,
  tokenOut:          MY_TOKEN,
  fee:               3000,      // 0.3%
  recipient:         myAddress,
  deadline:          Math.floor(Date.now() / 1000) + 3600,
  amountIn:          ethers.parseEther('1'),
  amountOutMinimum:  0,
  sqrtPriceLimitX96: 0
});

const quoter = new ethers.Contract('0x865E52Fe251D25b1aF7cae6B1AD3Af6C11EaDB7B', [
  'function quoteExactInputSingle((address,address,uint256,uint24,uint160)) view returns (uint256,uint160,uint32,uint256)'
], provider);

const [amountOut] = await quoter.quoteExactInputSingle({
  tokenIn:           WSHIDO,
  tokenOut:          MY_TOKEN,
  amountIn:          ethers.parseEther('1'),
  fee:               3000,
  sqrtPriceLimitX96: 0
});
console.log('Expected output:', ethers.formatEther(amountOut));

const factory = new ethers.Contract('0x9390b6bd008b8f52fE4711556B7E2A429A0eeBD2', [
  'function deploy(bytes32 salt, bytes bytecode) returns (address)',
  'function computeAddress(address deployer, bytes32 salt, bytes bytecode) pure returns (address)'
], signer);

const salt      = ethers.keccak256(ethers.toUtf8Bytes('my-unique-salt-v1'));
const bytecode  = MyContract__factory.bytecode;

// Predict address before deploying
const predicted = await factory.computeAddress(await signer.getAddress(), salt, bytecode);
console.log('Will deploy to:', predicted);

// Deploy
await factory.deploy(salt, bytecode);

# Check available snapshots
curl -s https://testnet.shidoscan.net/snapshots/snapshots.json | python3 -m json.tool

# Download latest snapshot URL
SNAP_URL=$(curl -s https://testnet.shidoscan.net/snapshots/snapshots.json | \
  python3 -c "import sys,json; print(json.load(sys.stdin)['snapshots'][0]['url'])")

# Download and extract to chain home
mkdir -p /data/.tmp-shidod
wget -O /tmp/snapshot.tar.gz "$SNAP_URL"
tar -xzf /tmp/snapshot.tar.gz -C /data/.tmp-shidod
rm /tmp/snapshot.tar.gz
echo "Snapshot extracted — skip to Step 5"

wget -q https://go.dev/dl/go1.21.5.linux-amd64.tar.gz -O /tmp/go.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf /tmp/go.tar.gz
echo 'export PATH=$PATH:/usr/local/go/bin:$HOME/go/bin' >> ~/.bashrc
source ~/.bashrc
go version

go install cosmossdk.io/tools/cosmovisor/cmd/[email protected]

sudo apt-get update -y && sudo apt-get install -y build-essential jq wget curl

wget https://github.com/ShidoGlobal/shido-testnet-terra-upgrade/releases/download/terra-upgrade/shidod
chmod +x shidod && sudo mv shidod /usr/local/bin/

sudo wget -O /usr/lib/libwasmvm.x86_64.so \
  https://github.com/CosmWasm/wasmvm/releases/download/v2.1.4/libwasmvm.x86_64.so
sudo ldconfig

shidod version

# Direct download (recommended)
curl -s https://testnet.shidoscan.net/snapshots/genesis.json > genesis.json

# Verify chain ID
python3 -c "import json; d=json.load(open('genesis.json')); print('Chain ID:', d['chain_id'])"

shidod config set client chain-id shido_9007-2 --home /data/.tmp-shidod
shidod config set client keyring-backend os --home /data/.tmp-shidod

shidod keys add validator --keyring-backend os --algo eth_secp256k1 --home /data/.tmp-shidod

shidod init MyValidator --chain-id shido_9007-2 --home /data/.tmp-shidod --overwrite

# Copy genesis (skip if you used Option A snapshot)
cp genesis.json /data/.tmp-shidod/config/genesis.json

# Gas cap for DeFi simulations (must be > 21000, not 0)
sed -i 's/gas-cap = .*/gas-cap = 50000000000/' /data/.tmp-shidod/config/app.toml

# Increase EVM call timeout
sed -i 's/evm-timeout = .*/evm-timeout = "60s"/' /data/.tmp-shidod/config/app.toml

# Set minimum gas price
sed -i 's/minimum-gas-prices = "0shido"/minimum-gas-prices = "0.25shido"/' /data/.tmp-shidod/config/app.toml

grep -E "gas-cap|evm-timeout|minimum-gas-prices" /data/.tmp-shidod/config/app.toml

sed -i 's/persistent_peers = ""/persistent_peers = "[email protected]:26656"/' \
  /data/.tmp-shidod/config/config.toml

sudo tee /etc/systemd/system/shidochain.service > /dev/null << 'SERVICE'
[Unit]
Description=Shido Testnet Node (shido_9007-2)
After=network-online.target
Wants=network-online.target

[Service]
User=root
Environment=DAEMON_NAME=shidod
Environment=DAEMON_HOME=/data/.tmp-shidod
Environment=DAEMON_ALLOW_DOWNLOAD_BINARIES=true
ExecStart=/root/go/bin/cosmovisor run start --home /data/.tmp-shidod
Restart=always
RestartSec=5
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
SERVICE

sudo systemctl daemon-reload
sudo systemctl enable shidochain.service
sudo systemctl start shidochain.service
sudo systemctl status shidochain.service

# Watch until catching_up = false
watch -n 3 'curl -s http://localhost:26657/status | python3 -c "import sys,json; s=json.load(sys.stdin)["result"]["sync_info"]; print("Height:", s["latest_block_height"], "| Catching up:", s["catching_up"])"'

# Get your validator EVM address to fund via faucet
shidod keys show validator --keyring-backend os --home /data/.tmp-shidod -e

shidod tx staking create-validator \
  --amount 100000000000000000000shido \
  --pubkey $(shidod tendermint show-validator --home /data/.tmp-shidod) \
  --moniker 'YourValidatorName' \
  --chain-id shido_9007-2 \
  --commission-rate 0.10 \
  --commission-max-rate 0.20 \
  --commission-max-change-rate 0.01 \
  --min-self-delegation 1 \
  --from validator \
  --keyring-backend os \
  --home /data/.tmp-shidod \
  --gas auto --gas-adjustment 1.5 -y