git.stevedylan.dev

yeesh 0beaf9c0

Steve · 2023-10-10 01:21 12 file(s) · +178 −127

contracts/CosmicCowboy.sol +25 −3

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

    Ownable
{
    uint256 private _nextTokenId;
    uint256 public latestTokenId;
    enum Location {
        Home,
        Bar,
        SupplyDepot
    }
    mapping(uint256 => Location) public tokenLocation;
    mapping(uint256 => uint8) public tokenHealth; // Mapping to store health of each token

    // Events
    event VisitArea(uint256 indexed tokenId, string location);
    event GetCurrentLocation(uint256 indexed tokenId, string location);
    event SetHealth(uint256 indexed tokenId, uint8 health); // Event emitted when health is set

    constructor(
        address initialOwner
    ) ERC721("Cosmic Cowboys", "CCNPC") Ownable(initialOwner) {}

    //function to set health
    function setHealth(uint256 tokenId, uint8 health) public onlyOwner {
        require(health >= 0 && health <= 10, "Health out of range"); // Check health is within valid range
        tokenHealth[tokenId] = health;
        emit SetHealth(tokenId, health); // Emit event
    }

    function safeMint(address to, string memory uri) public onlyOwner {
        uint256 tokenId = _nextTokenId++;
        latestTokenId = tokenId;
        _safeMint(to, tokenId);
        _setTokenURI(tokenId, uri);
        setHealth(tokenId, 10);
        tokenLocation[tokenId] = Location.Home;
    }

    // Function to get health of a token
    function getHealth(uint256 tokenId) external view returns (uint8) {
        return tokenHealth[tokenId];
    }

    // Function to visit a location

    function locationToString(
        Location _location
    ) internal pure returns (string memory) {
        if (_location == Location.Home) return "Home";
        if (_location == Location.SupplyDepot) return "Supply Depot";
        if (_location == Location.Bar) return "Bar";
        return "Supply Depot";
        return "Home";
    }

    // The following functions are overrides required by Solidity.

        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }

    function getOwner() external view returns (address) {
        return owner();
    }
}

contracts/ERC6551Account.sol +1 −1

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/introspection/IERC165.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721.sol";

contracts/ERC6551Registry.sol +1 −1

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/utils/Create2.sol";


contracts/GoldenCorn.sol +1 −1

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
pragma solidity ^0.8.0;

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

contracts/Operator.sol +51 −3

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/access/Ownable.sol";
import "./CosmicCowboy.sol";
import "./SpaceGrub.sol";
import "./RocketFuel.sol";
import "./ERC6551Account.sol";
import "./ERC6551Registry.sol";
import "./GoldenCorn.sol";
import "./SpaceSlop.sol";
import "./JupiterJunk.sol";

contract Operator is Ownable {
    CosmicCowboys public cosmicCowboys;
    GoldenCorn public goldenCorn;
    SpaceSlop public spaceSlop;
    JupiterJunk public jupiterJunk;

    uint256 public newTokenId;

    constructor(
        address initialOwner,
        address _cosmicCowboys,
        address _goldenCorn,
        address _spaceSlop,
        address _jupiterJunk
    ) Ownable(initialOwner) {
        cosmicCowboys = CosmicCowboys(_cosmicCowboys);
        goldenCorn = GoldenCorn(_goldenCorn);
        spaceSlop = SpaceSlop(_spaceSlop);
        jupiterJunk = JupiterJunk(_jupiterJunk);
    }

    function createNPC(address to, string memory uri) public {
        cosmicCowboys.safeMint(to, uri);
    }

    function getLatestTokenId() external view returns (uint256) {
        return cosmicCowboys.latestTokenId();
    }

    function equipNPC(
        address to,
        uint256 currencyAmount,
        uint256 foodAmount,
        uint256 suppliesAmount
    ) public {
        goldenCorn.mint(to, currencyAmount);
        spaceSlop.mint(to, foodAmount);
        jupiterJunk.mint(to, suppliesAmount);
    }

    function getOwner() external view returns (address) {
        return owner();
    }
}

contracts/RocketFuel.sol → contracts/SpaceSlop.sol +8 −11

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";

contract RocketFuel is ERC1155, Ownable, ERC1155Burnable, ERC1155Supply {
contract SpaceSlop is ERC1155, Ownable, ERC1155Burnable, ERC1155Supply {
    constructor(
        address initialOwner
    ) ERC1155("ipfs://CID") Ownable(initialOwner) {}
    )
        ERC1155("ipfs://QmRPT3zHx71Dd9KtRdYJkY9hsbu9RcCeRdoNWypJMpiybf")
        Ownable(initialOwner)
    {}

    function setURI(string memory newuri) public onlyOwner {
        _setURI(newuri);
    }

    function mint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public onlyOwner {
        _mint(account, id, amount, data);
    function mint(address account, uint256 amount) public onlyOwner {
        _mint(account, 0, amount, new bytes(0));
    }

    function mintBatch(

        super._update(from, to, ids, values);
    }
}


contracts/SpaceGrub.sol → contracts/JupiterJunk.sol +8 −10

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";

contract SpaceGrub is ERC1155, Ownable, ERC1155Burnable, ERC1155Supply {
contract JupiterJunk is ERC1155, Ownable, ERC1155Burnable, ERC1155Supply {
    constructor(
        address initialOwner
    ) ERC1155("ipfs://CID") Ownable(initialOwner) {}
    )
        ERC1155("ipfs://QmUE1hMRA85uaaoYAotPxXzAfVUy4hsMHyyjPXvayQQWHB")
        Ownable(initialOwner)
    {}

    function setURI(string memory newuri) public onlyOwner {
        _setURI(newuri);
    }

    function mint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public onlyOwner {
        _mint(account, id, amount, data);
    function mint(address account, uint256 amount) public onlyOwner {
        _mint(account, 0, amount, new bytes(0));
    }

    function mintBatch(

contracts/StellarSixShooter.sol (deleted) +0 −46

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol";
import "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Supply.sol";

contract SetllarSixShooter is ERC1155, Ownable, ERC1155Burnable, ERC1155Supply {
    constructor(
        address initialOwner
    ) ERC1155("ipfs://CID") Ownable(initialOwner) {}

    function setURI(string memory newuri) public onlyOwner {
        _setURI(newuri);
    }

    function mint(
        address account,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public onlyOwner {
        _mint(account, id, amount, data);
    }

    function mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public onlyOwner {
        _mintBatch(to, ids, amounts, data);
    }

    // The following functions are overrides required by Solidity.

    function _update(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory values
    ) internal override(ERC1155, ERC1155Supply) {
        super._update(from, to, ids, values);
    }
}

hardhat.config.js +12 −0

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

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: "0.8.20",
  networks: {
    goerli: {
      url: `${process.env.ALCHEMY_URL}`,
      accounts: [process.env.PRIVATE_KEY]
    },
    scroll: {
      url: "https://sepolia-rpc.scroll.io/",
      accounts: [process.env.PRIVATE_KEY]
    },
  }

};

package-lock.json +12 −0

      "name": "hardhat-project",
      "dependencies": {
        "@openzeppelin/contracts": "^5.0.0",
        "dotenv": "^16.3.1",
        "ethers": "^6.7.1"
      },
      "devDependencies": {

      },
      "engines": {
        "node": ">=8"
      }
    },
    "node_modules/dotenv": {
      "version": "16.3.1",
      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.3.1.tgz",
      "integrity": "sha512-IPzF4w4/Rd94bA9imS68tZBaYyBWSCE47V1RGuMrB94iyTOIEwRmVL2x/4An+6mETpLrKJ5hQkB8W4kFAadeIQ==",
      "engines": {
        "node": ">=12"
      },
      "funding": {
        "url": "https://github.com/motdotla/dotenv?sponsor=1"
      }
    },
    "node_modules/elliptic": {

package.json +1 −0

7	7		},
8	8		"dependencies": {
9	9		"@openzeppelin/contracts": "^5.0.0",
	10	+	"dotenv": "^16.3.1",
10	11		"ethers": "^6.7.1"
11	12		}
12	13		}

test/Test.js +58 −51

// Import the ethers library
const { ethers } = require("hardhat");

async function CosmicCoyboys() {
  let contract;
  let owner;
  let addr1;
  let addr2;

  // Get the signers from ethers
  [owner, addr1, addr2] = await ethers.getSigners();

  // Deploy the contract
  const Contract = await ethers.getContractFactory("CosmicCowboys");
  contract = await Contract.deploy(owner.address);
  const contractAddress = await contract.getAddress()
  console.log("Contract deployed to address:", contractAddress);

  // Mint tokens
  await contract.safeMint(addr1.address, "ipfs://QmVLwvmGehsrNEvhcCnnsw5RQNseohgEkFNN1848zNzdng");
  console.log("Minted token 1");
  await contract.safeMint(addr2.address, "ipfs://QmVLwvmGehsrNEvhcCnnsw5RQNseohgEkFNN1848zNzdng");
  console.log("Minted token 2");

  const tokenURI = await contract.tokenURI(1);
  console.log(tokenURI);
};
async function Operator() {

async function GoldenCorn() {
  let contract;
  let owner;
  let addr1;
  let addr2;
  let deployedAccountTx, deployedAccountReceipt, deployedAccountAddress;

  // Get the signers from ethers
  [owner, addr1, addr2] = await ethers.getSigners();

  // Deploy the contract
  const Contract = await ethers.getContractFactory("GoldenCorn");
  contract = await Contract.deploy(owner.address);
  const contractAddress = await contract.getAddress()
  console.log("Contract deployed to address:", contractAddress);
  // Deploy NPC contract
  const NPCContract = await ethers.getContractFactory("CosmicCowboys");
  const npcContract = await NPCContract.deploy(owner.address);
  const npcContractAddress = await npcContract.getAddress()
  console.log("NPC Contract deploywed to address:", npcContractAddress);

  // Mint tokens
  await contract.mint(addr1.address, 100);
  console.log("Minted token 1");
  // Deploy ERC-20 Contract
  const CurrencyContract = await ethers.getContractFactory("GoldenCorn");
  const currencyContract = await CurrencyContract.deploy(owner.address);
  const currencyContractAddress = await currencyContract.getAddress()
  console.log("NPC Contract deploywed to address:", currencyContractAddress);

  const balance = await contract.balanceOf(addr1.address);
  console.log(balance)
  // Deploy 1155 Contracts
  const FoodContract = await ethers.getContractFactory("SpaceSlop");
  const foodContract = await FoodContract.deploy(owner.address);
  const foodContractAddress = await foodContract.getAddress()
  console.log("NPC Contract deploywed to address:", foodContractAddress);

}

async function TBA() {
  let contract;
  let owner;
  let addr1;
  let addr2;
  const SupplyContract = await ethers.getContractFactory("JupiterJunk");
  const supplyContract = await SupplyContract.deploy(owner.address);
  const supplyContractAddress = await supplyContract.getAddress()
  console.log("NPC Contract deploywed to address:", supplyContractAddress);

  // Get the signers from ethers
  [owner, addr1, addr2] = await ethers.getSigners();

  // Deploy the contract
  // Deploy ERC6551
  const RegistryContract = await ethers.getContractFactory("ERC6551Registry");
  const regristryContract = await RegistryContract.deploy();
  const registryContractAddress = await regristryContract.getAddress()
  const registryContract = await RegistryContract.deploy();
  const registryContractAddress = await registryContract.getAddress()
  console.log("Registry Contract deployed to address:", registryContractAddress);

  const AccountContract = await ethers.getContractFactory("ERC6551Account");

  const accountContractAddress = await accountContract.getAddress()
  console.log("Account Contract deployed to address:", accountContractAddress);

}
  // Deploy Operator Contract
  const OperatorContract = await ethers.getContractFactory("Operator");
  const operatorContract = await OperatorContract.deploy(owner.address, npcContractAddress, currencyContractAddress, foodContractAddress, supplyContractAddress)
  const operatorContractAddress = await operatorContract.getAddress()
  console.log("Operator Contract deployed to address:", operatorContractAddress)

TBA()
  // Transfer NPC contract to Operator
  await npcContract.transferOwnership(operatorContractAddress);
  await currencyContract.transferOwnership(operatorContractAddress);
  await foodContract.transferOwnership(operatorContractAddress);
  await supplyContract.transferOwnership(operatorContractAddress);

  // create NPC
  const npcTx = await operatorContract.createNPC(owner.address, "ipfs://")
  const npcTxReceipt = await npcTx.wait()

  // After the NPC is created
  const latestTokenId = await operatorContract.getLatestTokenId();
  console.log("Latest Token ID:", latestTokenId.toString());

  // create TBA for NPC
  deployedAccountTx = await registryContract.createAccount(
    accountContractAddress,
    5,
    npcContractAddress,
    latestTokenId.toString(),
    0,
    "0x"
  )
  deployedAccountReceipt = await deployedAccountTx.wait()
  console.log(deployedAccountReceipt)

  // equip NPC via TBA

}

1	1		// SPDX-License-Identifier: MIT
2		-	pragma solidity ^0.8.20;
	2	+	pragma solidity ^0.8.0;
3	3
4	4		import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
5	5		import "@openzeppelin/contracts/token/ERC721/extensions/ERC721URIStorage.sol";

16	16		Ownable
17	17		{
18	18		uint256 private _nextTokenId;
	19	+	uint256 public latestTokenId;
19	20		enum Location {
20	21		Home,
21	22		Bar,
22	23		SupplyDepot
23	24		}
24	25		mapping(uint256 => Location) public tokenLocation;
	26	+	mapping(uint256 => uint8) public tokenHealth; // Mapping to store health of each token
25	27
26	28		// Events
27	29		event VisitArea(uint256 indexed tokenId, string location);
28	30		event GetCurrentLocation(uint256 indexed tokenId, string location);
	31	+	event SetHealth(uint256 indexed tokenId, uint8 health); // Event emitted when health is set
29	32
30	33		constructor(
31	34		address initialOwner
32	35		) ERC721("Cosmic Cowboys", "CCNPC") Ownable(initialOwner) {}
33	36
	37	+	//function to set health
	38	+	function setHealth(uint256 tokenId, uint8 health) public onlyOwner {
	39	+	require(health >= 0 && health <= 10, "Health out of range"); // Check health is within valid range
	40	+	tokenHealth[tokenId] = health;
	41	+	emit SetHealth(tokenId, health); // Emit event
	42	+	}
	43	+
34	44		function safeMint(address to, string memory uri) public onlyOwner {
35	45		uint256 tokenId = _nextTokenId++;
	46	+	latestTokenId = tokenId;
36	47		_safeMint(to, tokenId);
37	48		_setTokenURI(tokenId, uri);
	49	+	setHealth(tokenId, 10);
	50	+	tokenLocation[tokenId] = Location.Home;
	51	+	}
	52	+
	53	+	// Function to get health of a token
	54	+	function getHealth(uint256 tokenId) external view returns (uint8) {
	55	+	return tokenHealth[tokenId];
38	56		}
39	57
40	58		// Function to visit a location

57	75		function locationToString(
58	76		Location _location
59	77		) internal pure returns (string memory) {
60		-	if (_location == Location.Home) return "Home";
	78	+	if (_location == Location.SupplyDepot) return "Supply Depot";
61	79		if (_location == Location.Bar) return "Bar";
62		-	return "Supply Depot";
	80	+	return "Home";
63	81		}
64	82
65	83		// The following functions are overrides required by Solidity.

94	112		returns (bool)
95	113		{
96	114		return super.supportsInterface(interfaceId);
	115	+	}
	116	+
	117	+	function getOwner() external view returns (address) {
	118	+	return owner();
97	119		}
98	120		}

1	1		require("@nomicfoundation/hardhat-toolbox");
	2	+	require('dotenv').config()
2	3
3	4		/** @type import('hardhat/config').HardhatUserConfig */
4	5		module.exports = {
5	6		solidity: "0.8.20",
	7	+	networks: {
	8	+	goerli: {
	9	+	url: `${process.env.ALCHEMY_URL}`,
	10	+	accounts: [process.env.PRIVATE_KEY]
	11	+	},
	12	+	scroll: {
	13	+	url: "https://sepolia-rpc.scroll.io/",
	14	+	accounts: [process.env.PRIVATE_KEY]
	15	+	},
	16	+	}
	17	+
6	18		};

7	7		"name": "hardhat-project",
8	8		"dependencies": {
9	9		"@openzeppelin/contracts": "^5.0.0",
	10	+	"dotenv": "^16.3.1",
10	11		"ethers": "^6.7.1"
11	12		},
12	13		"devDependencies": {

3099	3100		},
3100	3101		"engines": {
3101	3102		"node": ">=8"
	3103	+	}
	3104	+	},
	3105	+	"node_modules/dotenv": {
	3106	+	"version": "16.3.1",
	3107	+	"resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.3.1.tgz",
	3108	+	"integrity": "sha512-IPzF4w4/Rd94bA9imS68tZBaYyBWSCE47V1RGuMrB94iyTOIEwRmVL2x/4An+6mETpLrKJ5hQkB8W4kFAadeIQ==",
	3109	+	"engines": {
	3110	+	"node": ">=12"
	3111	+	},
	3112	+	"funding": {
	3113	+	"url": "https://github.com/motdotla/dotenv?sponsor=1"
3102	3114		}
3103	3115		},
3104	3116		"node_modules/elliptic": {

1	1		// Import the ethers library
2	2		const { ethers } = require("hardhat");
3	3
4		-	async function CosmicCoyboys() {
5		-	let contract;
6		-	let owner;
7		-	let addr1;
8		-	let addr2;
9		-
10		-	// Get the signers from ethers
11		-	[owner, addr1, addr2] = await ethers.getSigners();
12		-
13		-	// Deploy the contract
14		-	const Contract = await ethers.getContractFactory("CosmicCowboys");
15		-	contract = await Contract.deploy(owner.address);
16		-	const contractAddress = await contract.getAddress()
17		-	console.log("Contract deployed to address:", contractAddress);
18		-
19		-	// Mint tokens
20		-	await contract.safeMint(addr1.address, "ipfs://QmVLwvmGehsrNEvhcCnnsw5RQNseohgEkFNN1848zNzdng");
21		-	console.log("Minted token 1");
22		-	await contract.safeMint(addr2.address, "ipfs://QmVLwvmGehsrNEvhcCnnsw5RQNseohgEkFNN1848zNzdng");
23		-	console.log("Minted token 2");
24		-
25		-	const tokenURI = await contract.tokenURI(1);
26		-	console.log(tokenURI);
27		-	};
	4	+	async function Operator() {
28	5
29		-	async function GoldenCorn() {
30		-	let contract;
31	6		let owner;
32	7		let addr1;
33	8		let addr2;
	9	+	let deployedAccountTx, deployedAccountReceipt, deployedAccountAddress;
34	10
35	11		// Get the signers from ethers
36	12		[owner, addr1, addr2] = await ethers.getSigners();
37	13
38		-	// Deploy the contract
39		-	const Contract = await ethers.getContractFactory("GoldenCorn");
40		-	contract = await Contract.deploy(owner.address);
41		-	const contractAddress = await contract.getAddress()
42		-	console.log("Contract deployed to address:", contractAddress);
	14	+	// Deploy NPC contract
	15	+	const NPCContract = await ethers.getContractFactory("CosmicCowboys");
	16	+	const npcContract = await NPCContract.deploy(owner.address);
	17	+	const npcContractAddress = await npcContract.getAddress()
	18	+	console.log("NPC Contract deploywed to address:", npcContractAddress);
43	19
44		-	// Mint tokens
45		-	await contract.mint(addr1.address, 100);
46		-	console.log("Minted token 1");
	20	+	// Deploy ERC-20 Contract
	21	+	const CurrencyContract = await ethers.getContractFactory("GoldenCorn");
	22	+	const currencyContract = await CurrencyContract.deploy(owner.address);
	23	+	const currencyContractAddress = await currencyContract.getAddress()
	24	+	console.log("NPC Contract deploywed to address:", currencyContractAddress);
47	25
48		-	const balance = await contract.balanceOf(addr1.address);
49		-	console.log(balance)
	26	+	// Deploy 1155 Contracts
	27	+	const FoodContract = await ethers.getContractFactory("SpaceSlop");
	28	+	const foodContract = await FoodContract.deploy(owner.address);
	29	+	const foodContractAddress = await foodContract.getAddress()
	30	+	console.log("NPC Contract deploywed to address:", foodContractAddress);
50	31
51		-	}
52		-
53		-	async function TBA() {
54		-	let contract;
55		-	let owner;
56		-	let addr1;
57		-	let addr2;
	32	+	const SupplyContract = await ethers.getContractFactory("JupiterJunk");
	33	+	const supplyContract = await SupplyContract.deploy(owner.address);
	34	+	const supplyContractAddress = await supplyContract.getAddress()
	35	+	console.log("NPC Contract deploywed to address:", supplyContractAddress);
58	36
59		-	// Get the signers from ethers
60		-	[owner, addr1, addr2] = await ethers.getSigners();
61		-
62		-	// Deploy the contract
	37	+	// Deploy ERC6551
63	38		const RegistryContract = await ethers.getContractFactory("ERC6551Registry");
64		-	const regristryContract = await RegistryContract.deploy();
65		-	const registryContractAddress = await regristryContract.getAddress()
	39	+	const registryContract = await RegistryContract.deploy();
	40	+	const registryContractAddress = await registryContract.getAddress()
66	41		console.log("Registry Contract deployed to address:", registryContractAddress);
67	42
68	43		const AccountContract = await ethers.getContractFactory("ERC6551Account");

70	45		const accountContractAddress = await accountContract.getAddress()
71	46		console.log("Account Contract deployed to address:", accountContractAddress);
72	47
73		-	}
	48	+	// Deploy Operator Contract
	49	+	const OperatorContract = await ethers.getContractFactory("Operator");
	50	+	const operatorContract = await OperatorContract.deploy(owner.address, npcContractAddress, currencyContractAddress, foodContractAddress, supplyContractAddress)
	51	+	const operatorContractAddress = await operatorContract.getAddress()
	52	+	console.log("Operator Contract deployed to address:", operatorContractAddress)
74	53
75		-	TBA()
	54	+	// Transfer NPC contract to Operator
	55	+	await npcContract.transferOwnership(operatorContractAddress);
	56	+	await currencyContract.transferOwnership(operatorContractAddress);
	57	+	await foodContract.transferOwnership(operatorContractAddress);
	58	+	await supplyContract.transferOwnership(operatorContractAddress);
	59	+
	60	+	// create NPC
	61	+	const npcTx = await operatorContract.createNPC(owner.address, "ipfs://")
	62	+	const npcTxReceipt = await npcTx.wait()
	63	+
	64	+	// After the NPC is created
	65	+	const latestTokenId = await operatorContract.getLatestTokenId();
	66	+	console.log("Latest Token ID:", latestTokenId.toString());
	67	+
	68	+	// create TBA for NPC
	69	+	deployedAccountTx = await registryContract.createAccount(
	70	+	accountContractAddress,
	71	+	5,
	72	+	npcContractAddress,
	73	+	latestTokenId.toString(),
	74	+	0,
	75	+	"0x"
	76	+	)
	77	+	deployedAccountReceipt = await deployedAccountTx.wait()
	78	+	console.log(deployedAccountReceipt)
	79	+
	80	+	// equip NPC via TBA
	81	+
	82	+	}