Contract

.github/workflows/test.yml

@@ -0,0 +1,43 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+env:
+  FOUNDRY_PROFILE: ci
+
+jobs:
+  check:
+    strategy:
+      fail-fast: true
+
+    name: Foundry project
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: recursive
+
+      - name: Install Foundry
+        uses: foundry-rs/foundry-toolchain@v1
+
+      - name: Show Forge version
+        run: |
+          forge --version
+
+      - name: Run Forge fmt
+        run: |
+          forge fmt --check
+        id: fmt
+
+      - name: Run Forge build
+        run: |
+          forge build --sizes
+        id: build
+
+      - name: Run Forge tests
+        run: |
+          forge test -vvv
+        id: test

.gitignore

@@ -48,3 +48,5 @@ out/
 .yarn/build-state.yml
 .yarn/install-state.gz
 .pnp.*
+
+/cache

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/forge-std"]
+	path = lib/forge-std
+	url = https://github.com/foundry-rs/forge-std

.yarnrc.yml

@@ -0,0 +1,20 @@
+enableGlobalCache: true
+
+enableTelemetry: false
+
+npmRegistryServer: "https://registry.npmjs.org"
+
+nodeLinker: node-modules
+
+supportedArchitectures:
+  cpu:
+    - x64
+    - arm64
+  libc:
+    - glibc
+    - musl
+  os:
+    - darwin
+    - linux
+
+yarnPath: .yarn/releases/yarn-4.6.0.cjs

README.md

@@ -1 +1,79 @@
-# namespace
+## Foundry
+
+**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
+
+Foundry consists of:
+
+- **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
+- **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
+- **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
+- **Chisel**: Fast, utilitarian, and verbose solidity REPL.
+
+## Documentation
+
+https://book.getfoundry.sh/
+
+## Usage
+
+### Build
+
+```shell
+$ forge build
+```
+
+### Test
+
+```shell
+$ forge test
+```
+
+### Format
+
+```shell
+$ forge fmt
+```
+
+### Gas Snapshots
+
+```shell
+$ forge snapshot
+```
+
+### Anvil
+
+```shell
+$ anvil
+```
+
+### Deploy
+
+```shell
+$ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --private-key <your_private_key>
+```
+
+### Cast
+
+```shell
+$ cast <subcommand>
+```
+
+### Help
+
+```shell
+$ forge --help
+$ anvil --help
+$ cast --help
+```
+
+# Verify contract
+
+```shell
+forge verify-contract \
+$CONTRACT_ADDRESS \
+src/Namespace.sol:Namespace \
+--chain-id $CHAIN_ID \
+--constructor-args $(cast abi-encode "constructor(address)" "$OWNER_ADDRESS") \
+--etherscan-api-key $ETHERSCAN_API_KEY \
+--compiler-version $COMPILER_VERSION \
+--watch
+```

codegen.js

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+
+
+const fs = require('node:fs').promises;
+const ethers = require('ethers');
+
+async function codegen(chainId) {
+  try {
+    console.log(`Cleaning './deployments/${chainId}'`);
+    await fs.rm(`./deployments/${chainId}`, {force: true, recursive: true});
+    await fs.mkdir(`./deployments/${chainId}`, {recursive: true});
+
+    const Namespace = {};
+
+    console.log(`Reading build from './out/Namespace.sol/Namespace.json'`);
+    Namespace.build = JSON.parse(await fs.readFile('./out/Namespace.sol/Namespace.json', 'utf8'));
+
+    console.log(
+      `Reading broadcast for Namespace ${chainId} from './broadcast/NamespaceDeployment.s.sol/${chainId}/run-latest.json'`
+    );
+    Namespace.broadcast = JSON.parse(
+      await fs.readFile(`./broadcast/NamespaceDeployment.s.sol/${chainId}/run-latest.json`, 'utf8')
+    );
+
+    console.log(`Reading deployments for Namespace from './deployments_${chainId}.json'`);
+    Namespace.address = JSON.parse(await fs.readFile(`./deployments_${chainId}.json`, 'utf8')).Namespace;
+
+    console.log(`Copying 'deployments_${chainId}.json' to 'deployments/${chainId}/deployments.json'`);
+    await fs.copyFile(`./deployments_${chainId}.json`, `deployments/${chainId}/deployments.json`);
+
+    console.log(`Writing 'deployments/${chainId}/Namespace.json'`);
+    await fs.writeFile(`deployments/${chainId}/Namespace.json`, JSON.stringify(Namespace.build.abi, null, 2), 'utf8');
+
+    console.log(`Writing 'deployments/${chainId}/Namespace.meta.json'`);
+    await fs.writeFile(
+      `deployments/${chainId}/Namespace.meta.json`,
+      JSON.stringify(
+        {
+          blockNumber: Number.parseInt(Namespace.broadcast.receipts[0].blockNumber, 16),
+          transactionHash: Namespace.broadcast.transactions[0].hash,
+          deployer: Namespace.broadcast.transactions[0].transaction.from,
+        },
+        null,
+        2
+      ),
+      'utf8'
+    );
+
+    console.log(`Writing 'deployments/${chainId}/Namespace.js'`);
+    await fs.writeFile(
+      `deployments/${chainId}/Namespace.js`,
+      [
+        `exports.address = "${Namespace.address}";`,
+        `exports.abi = ${JSON.stringify(new ethers.Interface(Namespace.build.abi).format(), null, 2)};`,
+      ].join('\n'),
+      'utf8'
+    );
+  } catch (error) {
+    console.error(`Error processing chainId ${chainId}:`, error.message || error);
+  }
+}
+
+async function main() {
+  try {
+    const namespaceDirectories = await fs.readdir('./broadcast/NamespaceDeployment.s.sol/', {withFileTypes: true});
+    if (namespaceDirectories.length === 0) {
+      throw new Error(`No chainId folders found in NamespaceDeployment.s.sol.`);
+    }
+    for (const dir of namespaceDirectories) {
+      if (dir.isDirectory()) {
+        const chainId = dir.name;
+        console.log(`Processing NamespaceDeployment for chainId ${chainId}`);
+        await codegen(chainId);
+      }
+    }
+
+  } catch (error) {
+    console.error(`Unhandled error in main function:`, error.message || error);
+  }
+}
+
+main();

cov.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+forge coverage -vvvvv --report lcov --report-file /tmp/lcov.info "$@"
+lcov --rc derive_function_end_line=0 --remove /tmp/lcov.info -o /tmp/clean.lcov.info '../node_modules/' 'test/' 'src/lib'
+genhtml --rc derive_function_end_line=0 /tmp/clean.lcov.info --output-directory coverage
+cp /tmp/clean.lcov.info ./coverage/lcov.info

deployments/11155420/Namespace.js

@@ -0,0 +1,45 @@
+exports.address = "0x359384BFFAddE2aA48c43579D25729cd852DA3ab";
+exports.abi = [
+  "constructor(address initialOwner, address whitelistAddress)",
+  "function approve(address to, uint256 tokenId)",
+  "function balanceOf(address owner) view returns (uint256)",
+  "function getApproved(uint256 tokenId) view returns (address)",
+  "function isApprovedForAll(address owner, address operator) view returns (bool)",
+  "function name() view returns (string)",
+  "function namespaceToTokenId(string) view returns (uint256)",
+  "function owner() view returns (address)",
+  "function ownerOf(uint256 tokenId) view returns (address)",
+  "function renounceOwnership()",
+  "function safeMint(string nameSpace)",
+  "function safeTransferFrom(address from, address to, uint256 tokenId)",
+  "function safeTransferFrom(address from, address to, uint256 tokenId, bytes data)",
+  "function setApprovalForAll(address operator, bool approved)",
+  "function setWhitelist(address _newWhitelistAddress)",
+  "function supportsInterface(bytes4 interfaceId) view returns (bool)",
+  "function symbol() view returns (string)",
+  "function tokenByIndex(uint256 index) view returns (uint256)",
+  "function tokenIdToNamespace(uint256) view returns (string)",
+  "function tokenOfOwnerByIndex(address owner, uint256 index) view returns (uint256)",
+  "function tokenURI(uint256 tokenId) view returns (string)",
+  "function totalSupply() view returns (uint256)",
+  "function transferFrom(address from, address to, uint256 tokenId)",
+  "function transferOwnership(address newOwner)",
+  "function whitelist() view returns (address)",
+  "event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId)",
+  "event ApprovalForAll(address indexed owner, address indexed operator, bool approved)",
+  "event OwnershipTransferred(address indexed previousOwner, address indexed newOwner)",
+  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)",
+  "event WhitelistSet(address indexed newWhitelistAddress)",
+  "error ERC721EnumerableForbiddenBatchMint()",
+  "error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner)",
+  "error ERC721InsufficientApproval(address operator, uint256 tokenId)",
+  "error ERC721InvalidApprover(address approver)",
+  "error ERC721InvalidOperator(address operator)",
+  "error ERC721InvalidOwner(address owner)",
+  "error ERC721InvalidReceiver(address receiver)",
+  "error ERC721InvalidSender(address sender)",
+  "error ERC721NonexistentToken(uint256 tokenId)",
+  "error ERC721OutOfBoundsIndex(address owner, uint256 index)",
+  "error OwnableInvalidOwner(address owner)",
+  "error OwnableUnauthorizedAccount(address account)"
+];