1. Install Docker
2. Install Kurtosis
3. mkdir private-network && cd private-network
4. vi network_params.yaml
5. kurtosis run github.com/ethpandaops/ethereum-package --args-file ./network_params.yaml --image-download always

participants:
  - el_type: geth
    cl_type: lighthouse
    count: 2
  - el_type: geth
    cl_type: teku

network_params:
  network_id: "695874"

additional_services:
  dora: {}

curl -X POST http://localhost:49996 \
-H "Content-Type: application/json" \
--data '{
"jsonrpc": "2.0",
"method": "eth_getBalance",
"params":
["0x8943545177806ED17B9F23F0a21ee
5948eCaa776", "latest"],
"id": 1
}'

{"jsonrpc":"2.0","id":1,"result":"0x33b2e3c9fd0803ce8000000"}

1. git clone https://github.com/zsystm/blockscout.git
2. cd blockscout/docker-compose
3. git checkout fastcampus
4. vi envs/common-blockscout.env
	4-1. ETHEREUM_JSONRPC_HTTP_URL=http://host.docker.internal:<your_geth_port>/
	4-2. ETHEREUM_JSONRPC_TRACE_URL=http://host.docker.internal:<your_geth_port>/
5. docker-compose -f geth.yml up -d

1. git clone https://github.com/zsystm/token-examples.git
2. cd token-examples
3. vi .env

ETH_RPC_URL="http://localhost:50302"
SENDER_PRIVATE_KEY="bcdf20249abf0ed6d944c0288fad489e33f66b3960d9e6229c1cd214ed3bbe31"
RECIPIENT_PRIVATE_KEY="39725efee3fb28614de3bacaffe4cc4bd8c436257e2c8bb887c4b5c4be45e76d"

pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/ERC20Permit.sol";

contract MyToken is ERC20, ERC20Permit {
    constructor() ERC20("MyToken", "MTK") ERC20Permit("MyToken") {
        _mint(msg.sender, 1000000000000000000);
    }
}

require("dotenv").config();
const fs = require("fs");
const { Wallet, ethers, BigNumber } = require("ethers");

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function deployAndExecuteContract() {
  // Load contract ABI and Bytecode
  const abi = JSON.parse(fs.readFileSync("contracts/erc20.abi", "utf8"));
  let bytecode = fs
    .readFileSync("contracts/erc20.bytecode", "utf8")
    .replace(/\n/g, "");

  // Setup Provider & Wallet (Private key and RPC URL loaded from .env)
  const privateKey = process.env.SENDER_PRIVATE_KEY;
  const provider = new ethers.providers.JsonRpcProvider(
    process.env.ETH_RPC_URL || "http://localhost:8545"
  );
  const wallet = new Wallet(privateKey, provider);
  const sender = wallet.address;

  console.log(`🟢 Sender Address: ${sender}`);

  // Check Native Balance (Used for Gas Fee)
  const beforeBalance = await provider.getBalance(sender);
  console.log(
    `💰 Native Balance of Sender: ${ethers.utils.formatEther(
      beforeBalance
    )} ETH`
  );

// Deploy Contract
  console.log(`🚀 Deploying ERC20 contract...`);
  const contractFactory = new ethers.ContractFactory(abi, bytecode, wallet);
  const contract = await contractFactory.deploy({ gasLimit: 5000000 });

  console.log(`⏳ Waiting for contract deployment...`);
  await contract.deployTransaction.wait();
  console.log(`✅ Contract deployed at: ${contract.address}`);

  // Query Deploy Transaction Receipt
  await delay(5000); // Wait for confirmation
  const deployReceipt = await provider.getTransactionReceipt(
    contract.deployTransaction.hash
  );
  console.log(`📜 Deploy TX Receipt:`, deployReceipt);

// Define recipient and amount
  const recipientWallet = new Wallet(
    process.env.RECIPIENT_PRIVATE_KEY,
    provider
  ); 
  const recipient = recipientWallet.address;
  const amount = BigNumber.from(10); 

  // Check ERC20 Balances Before Transfer (Initial balance set by constructor)
  let senderBalance = await contract.balanceOf(sender);
  let recipientBalance = await contract.balanceOf(recipient);
  console.log(`🔹 Sender ERC20 Balance: ${senderBalance.toString()}`);
  console.log(`🔹 Recipient ERC20 Balance: ${recipientBalance.toString()}`);

  // Guard clause for insufficient balance
  if (senderBalance.lt(amount)) {
    console.error(`❌ Insufficient ERC20 balance for transfer`);
    return;
  }

// Perform ERC20 Transfer
  console.log(
    `📤 Transferring ${amount.toString()} ERC20 tokens to ${recipient}`
  );
  const transferTx = await contract.transfer(recipient, amount, {
    gasLimit: 100000,
  });
  console.log(`⏳ Waiting for transfer to confirm...`);
  await transferTx.wait();
  console.log(`✅ Transfer TX Hash: ${transferTx.hash}`);

  // Query Transfer Event and Check Updated Balances
  const transferReceipt = await provider.getTransactionReceipt(transferTx.hash);
  console.log(`📜 Transfer TX Receipt:`, transferReceipt);

  await delay(5000); // Wait for logs to be indexed

  // Fetch Transfer Event Logs
  const transferEvents = await contract.queryFilter(
    contract.filters.Transfer(sender, recipient)
  );
  transferEvents.forEach((event) => {
    console.log(
      `📩 Transfer Event: ${event.args.from} → ${
        event.args.to
      }, Amount: ${event.args.value.toString()}`
    );
  });

  // Check Updated Balances
  senderBalance = await contract.balanceOf(sender);
  recipientBalance = await contract.balanceOf(recipient);
  console.log(
    `🔹 Sender ERC20 Balance After Transfer: ${senderBalance.toString()}`
  );
  console.log(
    `🔹 Recipient ERC20 Balance After Transfer: ${recipientBalance.toString()}`
  );

// ========== APPROVE CASE ==========
  console.log(
    `🔹 Approving ${recipient} to spend ${amount.toString()} tokens on behalf of sender`
  );
  const approveTx = await contract.approve(recipient, amount, {
    gasLimit: 100000,
  });
  await approveTx.wait();
  console.log(`✅ Approval TX Hash: ${approveTx.hash}`);

  // Query Approval Event
  const approvalReceipt = await provider.getTransactionReceipt(approveTx.hash);
  console.log(`📜 Approval TX Receipt:`, approvalReceipt);

  // Fetch Approval Event Logs
  const approvalEvents = await contract.queryFilter(
    contract.filters.Approval(sender, recipient)
  );
  approvalEvents.forEach((event) => {
    console.log(
      `📩 Approval Event: Owner ${event.args.owner} → Spender ${
        event.args.spender
      }, Amount: ${event.args.value.toString()}`
    );
  });

// ========== TRANSFER FROM ==========
  console.log(
    `📤 ${recipient} attempting to transfer ${amount.toString()} tokens from ${sender}`
  );

  // Connect as recipient to execute transferFrom (Acts as the Spender)
  const recipientContract = contract.connect(recipientWallet);

  const newRecipient = "0x614561D2d143621E126e87831AEF287678B442b8";
  let newRecipientBalance = await contract.balanceOf(newRecipient);
  console.log(
    `🔹 New Recipient ERC20 Balance: ${newRecipientBalance.toString()}`
  );
  
  // Execute transferFrom
  const transferFromTx = await recipientContract.transferFrom(
    sender,
    newRecipient,
    amount,
    { gasLimit: 100000 }
  );
  await transferFromTx.wait();
  console.log(`✅ TransferFrom TX Hash: ${transferFromTx.hash}`);

  // Fetch TransferFrom Event Logs (Note: This still tracks the transfer event)
  const transferFromEvents = await contract.queryFilter(
    contract.filters.Transfer(sender, recipient)
  );
  transferFromEvents.forEach((event) => {
    console.log(
      `📩 TransferFrom Event: ${event.args.from} → ${
        event.args.to
      }, Amount: ${event.args.value.toString()}`
    );
  });

// Check Balances After TransferFrom
  senderBalance = await contract.balanceOf(sender);
  newRecipientBalance = await contract.balanceOf(newRecipient);
  console.log(
    `🔹 Sender ERC20 Balance After transferFrom: ${senderBalance.toString()}`
  );
  console.log(
    `🔹 New Recipient ERC20 Balance After transferFrom: ${newRecipientBalance.toString()}`
  );

  // Check Native Balance
  const afterBalance = await provider.getBalance(sender);
  console.log(
    `💰 Native Balance of Sender after all txs: ${ethers.utils.formatEther(
      afterBalance
    )} ETH`
  );
}

deployAndExecuteContract();

require("dotenv").config();
const fs = require("fs");
const { Wallet, ethers } = require("ethers");

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function deployAndExecuteNFTContract() {
  // Load contract ABI and Bytecode
  const abi = JSON.parse(fs.readFileSync("contracts/erc721.abi", "utf8"));
  let bytecode = fs
    .readFileSync("contracts/erc721.bytecode", "utf8")
    .replace(/\n/g, "");

  // Setup Provider & Wallet
  const privateKey = process.env.SENDER_PRIVATE_KEY;
  const provider = new ethers.providers.JsonRpcProvider(
    process.env.ETH_RPC_URL || "http://localhost:8545"
  );
  const wallet = new Wallet(privateKey, provider);
  const sender = wallet.address;

  console.log(`🟢 Sender Address: ${sender}`);

// Deploy Contract
  console.log(`🚀 Deploying MyToken (ERC721) contract...`);
  const contractFactory = new ethers.ContractFactory(abi, bytecode, wallet);
  const contract = await contractFactory.deploy({ gasLimit: 5000000 });

  console.log(`⏳ Waiting for contract deployment...`);
  await contract.deployTransaction.wait();
  console.log(`✅ Contract deployed at: ${contract.address}`);

  await delay(5000);

  // Query Deploy Transaction Receipt
  const deployReceipt = await provider.getTransactionReceipt(
    contract.deployTransaction.hash
  );
  console.log(`📜 Deploy TX Receipt:`, deployReceipt);

// Define recipient and token ID
  const recipientWallet = new Wallet(
    process.env.RECIPIENT_PRIVATE_KEY,
    provider
  );
  const recipient = recipientWallet.address;
  const tokenId = 0; // First minted NFT

  // Check Initial NFT Ownership
  let owner = await contract.ownerOf(tokenId);
  console.log(`🔹 Owner of Token ID ${tokenId}: ${owner}`);

  if (owner !== sender) {
    console.error(`❌ Unexpected NFT owner. Expected ${sender}, but got ${owner}.`);
    return;
  }

// Approve Recipient for NFT Transfer
  console.log(`🔹 Approving ${recipient} to transfer Token ID ${tokenId}`);
  const approveTx = await contract.approve(recipient, tokenId, {
    gasLimit: 100000,
  });
  await approveTx.wait();
  console.log(`✅ Approval TX Hash: ${approveTx.hash}`);

  // Fetch Approval Event Logs
  const approvalEvents = await contract.queryFilter(
    contract.filters.Approval(sender, recipient)
  );
  approvalEvents.forEach((event) => {
    console.log(
      `📩 Approval Event: Owner ${event.args.owner} → Approved ${event.args.approved}, Token ID: ${event.args.tokenId.toString()}`
    );
  });

const newRecipient = "0x614561D2d143621E126e87831AEF287678B442b8";
  // Execute Transfer as Recipient
  console.log(`📤 ${recipient} attempting to transfer NFT Token ID ${tokenId} to ${newRecipient}`);

  const recipientContract = contract.connect(recipientWallet);
  const transferTx = await recipientContract["safeTransferFrom(address,address,uint256)"](
    sender,
    newRecipient,
    tokenId,
    { gasLimit: 100000 }
  );
  await transferTx.wait();
  console.log(`✅ Transfer TX Hash: ${transferTx.hash}`);

// Fetch Transfer Event Logs
  const transferEvents = await contract.queryFilter(
    contract.filters.Transfer(sender, recipient)
  );
  transferEvents.forEach((event) => {
    console.log(
      `📩 Transfer Event: ${event.args.from} → ${event.args.to}, Token ID: ${event.args.tokenId.toString()}`
    );
  });

  // Check Final Owner
  const finalOwner = await contract.ownerOf(tokenId);
  console.log(`🔹 Final Owner of Token ID ${tokenId}: ${finalOwner}`);
}

deployAndExecuteNFTContract();