Building on GOAT Network

my-goat-project/
├── contracts/
│   └── MyContract.sol
├── scripts/
│   ├── deploy.ts
│   └── interact.ts
├── test/
│   └── MyContract.test.ts
├── .env
├── hardhat.config.ts
├── package.json
└── README.md

// hardhat.config.ts
import { HardhatUserConfig } from "hardhat/config";
import "@nomicfoundation/hardhat-toolbox";
import * as dotenv from "dotenv";
 
dotenv.config();
 
const config: HardhatUserConfig = {
  solidity: "0.8.19",
  networks: {
    goatTestnet: {
      url: "https://rpc.testnet3.goat.network",
      chainId: 48816,
      accounts: process.env.PRIVATE_KEY ? [process.env.PRIVATE_KEY] : [],
    },
    hardhat: {
      mining: {
        auto: true,
        interval: 5000
      }
    }
  },
  etherscan: {
    apiKey: {
      goatTestnet: process.env.EXPLORER_API_KEY || ""
    },
    customChains: [
      {
        network: "goatTestnet",
        chainId: 48816,
        urls: {
          apiURL: "https://explorer.testnet3.goat.network/api",
          browserURL: "https://explorer.testnet3.goat.network"
        }
      }
    ]
  }
};
 
export default config;

export async function addGoatTestnetToMetaMask() {
  try {
    await window.ethereum.request({
      method: 'wallet_addEthereumChain',
      params: [{
        chainId: '0xBEA0', // 48816 in hex
        chainName: 'GOAT Testnet3',
        nativeCurrency: {
          name: 'Bitcoin',
          symbol: 'BTC',
          decimals: 18
        },
        rpcUrls: ['https://rpc.testnet3.goat.network'],
        blockExplorerUrls: ['https://explorer.testnet3.goat.network']
      }]
    });
  } catch (error) {
    console.error('Failed to add GOAT Testnet3:', error);
  }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
 
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
 
contract GOATToken is ERC20, Ownable {
    constructor() ERC20("GOAT Token", "GOAT") {
        _mint(msg.sender, 1000000 * 10 ** decimals());
    }
 
    function mint(address to, uint256 amount) public onlyOwner {
        _mint(to, amount);
    }
}

// scripts/deploy.ts
import { ethers } from "hardhat";
 
async function main() {
  const GOATToken = await ethers.getContractFactory("GOATToken");
  const token = await GOATToken.deploy();
  await token.deployed();
 
  console.log(`GOATToken deployed to: ${token.address}`);
}
 
main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

// test/GOATToken.test.ts
import { expect } from "chai";
import { ethers } from "hardhat";
import { GOATToken } from "../typechain-types";
 
describe("GOATToken", function () {
  let token: GOATToken;
 
  beforeEach(async function () {
    const GOATToken = await ethers.getContractFactory("GOATToken");
    token = await GOATToken.deploy();
    await token.deployed();
  });
 
  it("Should have correct initial supply", async function () {
    const totalSupply = await token.totalSupply();
    expect(totalSupply).to.equal(ethers.utils.parseEther("1000000"));
  });
});

import { ethers } from 'ethers';
 
export function getGoatProvider() {
  // For browser environments
  if (window.ethereum) {
    return new ethers.providers.Web3Provider(window.ethereum);
  }
  
  // For backend or fallback
  return new ethers.providers.JsonRpcProvider(
    "https://rpc.testnet3.goat.network"
  );
}
 
export async function connectWallet() {
  const provider = getGoatProvider();
  await provider.send("eth_requestAccounts", []);
  return provider.getSigner();
}

import { ethers } from 'ethers';
import GOATTokenABI from './abis/GOATToken.json';
 
export class GOATTokenClient {
  private contract: ethers.Contract;
  private signer: ethers.Signer;
 
  constructor(
    contractAddress: string,
    signer: ethers.Signer
  ) {
    this.contract = new ethers.Contract(
      contractAddress,
      GOATTokenABI,
      signer
    );
    this.signer = signer;
  }
 
  async getBalance(address: string): Promise<string> {
    const balance = await this.contract.balanceOf(address);
    return ethers.utils.formatEther(balance);
  }
 
  async transfer(to: string, amount: string): Promise<ethers.ContractTransaction> {
    const parsedAmount = ethers.utils.parseEther(amount);
    return await this.contract.transfer(to, parsedAmount);
  }
}