@paimaexample/evm-contracts 0.3.0

package/src/contracts/token/InverseBaseProjected1155.sol

@@ -0,0 +1,170 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
+import {IERC1155MetadataURI} from "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IInverseProjected1155} from "./IInverseProjected1155.sol";
+import {IInverseBaseProjected1155} from "./IInverseBaseProjected1155.sol";
+import {IUri} from "./IUri.sol";
+
+/// @dev A Paima Inverse Projection ERC1155 token where initialization is handled by the base-layer.
+/// A standard ERC1155 that accepts calldata in the mint function for any initialization data needed in a Paima dApp.
+contract InverseBaseProjected1155 is IInverseBaseProjected1155, ERC1155, Ownable {
+    using Strings for uint256;
+
+    string public name;
+    string public symbol;
+
+    /// @dev The token ID that will be minted when calling the `mint` function.
+    uint256 public currentTokenId;
+    /// @dev Base URI that is used in the `uri` function to form the start of the token URI.
+    string public baseURI;
+    /// @dev Base extension that is used in the `uri` function to form the end of the token URI.
+    string public baseExtension;
+
+    mapping(uint256 id => uint256) private _totalSupply;
+
+    /// @dev Sets the NFT's `name`, `symbol`, and transfers ownership to `owner`.
+    /// Also sets `currentTokenId` to 1.
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _owner
+    ) ERC1155("") Ownable(_owner) {
+        name = _name;
+        symbol = _symbol;
+        currentTokenId = 1;
+        baseExtension = ".json";
+    }
+
+    /// @dev Returns true if this contract implements the interface defined by `interfaceId`. See EIP165.
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view virtual override(IERC165, ERC1155) returns (bool) {
+        return
+            interfaceId == type(IInverseProjected1155).interfaceId ||
+            interfaceId == type(IInverseBaseProjected1155).interfaceId ||
+            super.supportsInterface(interfaceId);
+    }
+
+    /// @dev Returns the total amount of tokens with ID `id` that currently exists.
+    function totalSupply(uint256 id) public view virtual returns (uint256) {
+        return _totalSupply[id];
+    }
+
+    /// @dev Mints `value` of a new token to transaction sender, passing `initialData` to be emitted in the event.
+    /// Increases the `currentTokenId`.
+    /// Reverts if transaction sender is a smart contract that does not implement IERC1155Receiver-onERC1155Received.
+    /// Emits the `Minted` event.
+    /// @param value the amount of tokens to mint.
+    /// @param data additional data to pass to the receiver contract.
+    /// @param initialData data that is emitted in the `Minted` event.
+    /// @return id of the minted token.
+    function mint(
+        uint256 value,
+        bytes memory data,
+        string calldata initialData
+    ) public virtual returns (uint256) {
+        uint256 tokenId = currentTokenId;
+        _mint(msg.sender, tokenId, value, data);
+
+        currentTokenId++;
+
+        emit Minted(tokenId, value, initialData);
+        return tokenId;
+    }
+
+    /// @dev Burns `value` amount of token of ID `id` from transaction sender.
+    /// Reverts if transaction sender's balance of `id` is less than `value`.
+    function burn(uint256 id, uint256 value) public virtual {
+        _burn(msg.sender, id, value);
+    }
+
+    /// @dev Burns batch of `values` amounts of tokens of IDs `ids` from transaction sender.
+    /// Reverts if transaction sender's balance of any `id` is less than `value`.
+    function burnBatch(uint256[] memory ids, uint256[] memory values) public virtual {
+        _burnBatch(msg.sender, ids, values);
+    }
+
+    /// @dev Returns the token URI of specified `id` using the default set base URI.
+    function uri(
+        uint256 id
+    ) public view virtual override(ERC1155, IERC1155MetadataURI) returns (string memory) {
+        return uri(id, baseURI);
+    }
+
+    /// @dev Returns the token URI of specified `id` using a custom base URI.
+    function uri(
+        uint256 id,
+        string memory customBaseUri
+    ) public view virtual returns (string memory) {
+        require(_totalSupply[id] > 0, "InverseBaseProjected1155: URI query for nonexistent token");
+        string memory URI = bytes(customBaseUri).length > 0
+            ? string.concat(customBaseUri, "eip155:", block.chainid.toString(), "/", id.toString())
+            : "";
+        return string(abi.encodePacked(URI, baseExtension));
+    }
+
+    /// @dev Returns the token URI of specified `id` using a call to contract implementing `IUri`.
+    function uri(uint256 id, IUri customUriInterface) public view virtual returns (string memory) {
+        return customUriInterface.uri(id);
+    }
+
+    /// @dev Sets `_URI` as the `baseURI` of the NFT.
+    /// Callable only by the contract owner.
+    /// Emits the `SetBaseURI` event.
+    function setBaseURI(string memory _URI) public virtual onlyOwner {
+        string memory oldURI = baseURI;
+        baseURI = _URI;
+        emit SetBaseURI(oldURI, _URI);
+    }
+
+    /// @dev Sets `_newBaseExtension` as the `baseExtension` of the NFT.
+    /// Callable only by the contract owner.
+    function setBaseExtension(string memory _newBaseExtension) public virtual onlyOwner {
+        string memory oldBaseExtension = baseExtension;
+        baseExtension = _newBaseExtension;
+        emit SetBaseURI(oldBaseExtension, _newBaseExtension);
+    }
+
+    /// @dev Function that emits an event to notify third-parties (e.g. NFT marketplaces) about
+    /// an update to consecutive range of tokens. Can be overridden in inheriting contract.
+    function updateMetadataBatch(uint256 _fromTokenId, uint256 _toTokenId) public virtual {
+        emit BatchMetadataUpdate(_fromTokenId, _toTokenId);
+    }
+
+    /// @dev Function that emits an event to notify third-parties (e.g. NFT marketplaces) about
+    /// an update to a single token. Can be overridden in inheriting contract.
+    function updateMetadata(uint256 _tokenId) public virtual {
+        emit MetadataUpdate(_tokenId);
+    }
+
+    /// @dev See {ERC1155-_update}.
+    function _update(
+        address from,
+        address to,
+        uint256[] memory ids,
+        uint256[] memory values
+    ) internal virtual override {
+        super._update(from, to, ids, values);
+
+        if (from == address(0)) {
+            for (uint256 i = 0; i < ids.length; ++i) {
+                // Overflow check required: The rest of the code assumes that totalSupply never overflows
+                _totalSupply[ids[i]] += values[i];
+            }
+        }
+
+        if (to == address(0)) {
+            for (uint256 i = 0; i < ids.length; ++i) {
+                unchecked {
+                    // Overflow not possible: values[i] <= balanceOf(from, ids[i]) <= totalSupply(ids[i])
+                    _totalSupply[ids[i]] -= values[i];
+                }
+            }
+        }
+    }
+}

package/src/contracts/token/InverseBaseProjectedNft.sol

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import {IERC721Metadata} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IInverseProjectedNft} from "./IInverseProjectedNft.sol";
+import {IInverseBaseProjectedNft} from "./IInverseBaseProjectedNft.sol";
+import {ITokenUri} from "./ITokenUri.sol";
+
+/// @dev A standard ERC721 that accepts calldata in the mint function for any initialization data needed in a Paima dApp.
+/// See PRC3 for more.
+contract InverseBaseProjectedNft is IInverseBaseProjectedNft, ERC721, Ownable {
+    using Strings for uint256;
+
+    /// @dev The token ID that will be minted when calling the `mint` function.
+    uint256 public currentTokenId;
+    /// @dev Base URI that is used in the `tokenURI` function to form the start of the token URI.
+    string public baseURI;
+    /// @dev Total token supply, increased by minting and decreased by burning.
+    uint256 public totalSupply;
+    /// @dev Base extension that is used in the `tokenURI` function to form the end of the token URI.
+    string public baseExtension;
+
+    /// @dev Reverts if `msg.sender` is not the specified token's owner.
+    modifier onlyTokenOwner(uint256 tokenId) {
+        require(msg.sender == ownerOf(tokenId), "InverseBaseProjectedNft: not owner");
+        _;
+    }
+
+    /// @dev Sets the NFT's `name`, `symbol`, and transfers ownership to `owner`.
+    /// Also sets `currentTokenId` to 1 and `baseExtension` to `".json"`.
+    constructor(
+        string memory name,
+        string memory symbol,
+        address owner
+    ) ERC721(name, symbol) Ownable(owner) {
+        currentTokenId = 1;
+        baseExtension = ".json";
+    }
+
+    /// @dev Returns true if this contract implements the interface defined by `interfaceId`. See EIP165.
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view virtual override(IERC165, ERC721) returns (bool) {
+        return
+            interfaceId == type(IInverseProjectedNft).interfaceId ||
+            interfaceId == type(IInverseBaseProjectedNft).interfaceId ||
+            interfaceId == bytes4(0x49064906) ||
+            super.supportsInterface(interfaceId);
+    }
+
+    /// @dev Mints a new token to address `_to`, passing `initialData` to be emitted in the event.
+    /// Increases the `totalSupply` and `currentTokenId`.
+    /// Reverts if `_to` is a zero address or if it refers to smart contract but does not implement IERC721Receiver-onERC721Received.
+    /// Emits the `Minted` event.
+    /// @param _to where to send the NFT to
+    /// @param initialData data that is emitted in the `Minted` event
+    /// @param data any additional data to pass to the receiver contract
+    /// @return id of the minted token
+    function mint(
+        address _to,
+        string calldata initialData,
+        bytes memory data
+    ) public virtual returns (uint256) {
+        require(_to != address(0), "InverseBaseProjectedNft: zero receiver address");
+
+        uint256 tokenId = currentTokenId;
+        _safeMint(_to, tokenId, data);
+
+        totalSupply++;
+        currentTokenId++;
+
+        emit Minted(tokenId, initialData);
+        return tokenId;
+    }
+
+    /// @dev Shorthand function that calls the `mint` function with empty `data`.
+    function mint(address _to, string calldata initialData) public virtual returns (uint256) {
+        return mint(_to, initialData, bytes(""));
+    }
+
+    /// @dev Burns token of ID `_tokenId`. Callable only by the owner of the specified token.
+    /// Reverts if `_tokenId` does not exist.
+    function burn(uint256 _tokenId) public virtual onlyTokenOwner(_tokenId) {
+        totalSupply--;
+        _burn(_tokenId);
+    }
+
+    /// @dev Returns the `baseURI` of this NFT.
+    function _baseURI() internal view virtual override returns (string memory) {
+        return baseURI;
+    }
+
+    /// @dev Returns the token URI of specified `tokenId` using the default set base URI.
+    function tokenURI(
+        uint256 tokenId
+    ) public view virtual override(ERC721, IERC721Metadata) returns (string memory) {
+        return tokenURI(tokenId, _baseURI());
+    }
+
+    /// @dev Returns the token URI of specified `tokenId` using a custom base URI.
+    function tokenURI(
+        uint256 tokenId,
+        string memory customBaseUri
+    ) public view virtual returns (string memory) {
+        _requireOwned(tokenId);
+        string memory URI = bytes(customBaseUri).length > 0
+            ? string.concat(
+                customBaseUri,
+                "eip155:",
+                block.chainid.toString(),
+                "/",
+                tokenId.toString()
+            )
+            : "";
+        return string(abi.encodePacked(URI, baseExtension));
+    }
+
+    /// @dev Returns the token URI of specified `tokenId` using a call to contract implementing `ITokenUri`.
+    function tokenURI(
+        uint256 tokenId,
+        ITokenUri customUriInterface
+    ) public view returns (string memory) {
+        return customUriInterface.tokenURI(tokenId);
+    }
+
+    /// @dev Sets `_URI` as the `baseURI` of the NFT.
+    /// Callable only by the contract owner.
+    /// Emits the `SetBaseURI` event.
+    function setBaseURI(string memory _URI) public virtual onlyOwner {
+        string memory oldURI = baseURI;
+        baseURI = _URI;
+        emit SetBaseURI(oldURI, _URI);
+    }
+
+    /// @dev Sets `_newBaseExtension` as the `baseExtension` of the NFT.
+    /// Callable only by the contract owner.
+    function setBaseExtension(string memory _newBaseExtension) public virtual onlyOwner {
+        string memory oldBaseExtension = baseExtension;
+        baseExtension = _newBaseExtension;
+        emit SetBaseURI(oldBaseExtension, _newBaseExtension);
+    }
+
+    /// @dev Function that emits an event to notify third-parties (e.g. NFT marketplaces) about
+    /// an update to consecutive range of tokens. Can be overridden in inheriting contract.
+    function updateMetadataBatch(uint256 _fromTokenId, uint256 _toTokenId) public virtual {
+        emit BatchMetadataUpdate(_fromTokenId, _toTokenId);
+    }
+
+    /// @dev Function that emits an event to notify third-parties (e.g. NFT marketplaces) about
+    /// an update to a single token. Can be overridden in inheriting contract.
+    function updateMetadata(uint256 _tokenId) public virtual {
+        emit MetadataUpdate(_tokenId);
+    }
+}

package/src/plugin/common.ts

@@ -0,0 +1,35 @@
+// import type { HardhatRuntimeEnvironment } from 'hardhat/types';
+// import { isAddress } from 'viem';
+// import type { WalletClient } from 'viem';
+// import { scope } from 'hardhat/config';
+// import { createInterface } from 'node:readline/promises';
+// import { stdin, stdout } from 'process';
+
+// export const paimaScope = scope('paima', 'Paima Engine tasks');
+
+// const rl = createInterface({ input: stdin, output: stdout });
+
+// export async function getOrAskString(cmdLineValue: unknown, question: string): Promise<string> {
+//   if (cmdLineValue != null && typeof cmdLineValue !== 'string') {
+//     throw new Error(`Invalid type passed. Expected string: ${JSON.stringify(cmdLineValue)}`);
+//   }
+//   return cmdLineValue != null ? cmdLineValue : await rl.question(question);
+// }
+// export async function getContract(
+//   hre: HardhatRuntimeEnvironment,
+//   cmdLineAccount: unknown
+// ): Promise<{ signer: WalletClient; account: `0x${string}` }> {
+//   const account = await getOrAskString(cmdLineAccount, 'Contract address? ');
+//   if (!isAddress(account)) {
+//     throw new Error(`Invalid contract address passed ${account}`);
+//   }
+
+//   const wallets = await hre.viem.getWalletClients();
+
+//   return { signer: wallets[0], account };
+// }
+// export function ownerCheck(expectedOwner: string, caller: string): void {
+//   if (expectedOwner !== caller) {
+//     throw new Error(`Owner mismatch. Expected ${expectedOwner}, but signer was ${caller}`);
+//   }
+// }

package/src/plugin/deployment.ts

@@ -0,0 +1,161 @@
+// import { types } from "hardhat/config";
+// import { listDeployments } from "@nomicfoundation/ignition-core";
+// import * as path from "path";
+// import * as fs from "fs";
+// import { paimaScope } from "./common.js";
+// import * as ts from "typescript";
+// import * as dom from "dts-dom";
+
+// paimaScope
+//   .task(
+//     "copy-ignition-deployment",
+//     `Copy the hardhat-ignition deployed addresses information to a target folder`,
+//   )
+//   .addParam(
+//     "rootDir",
+//     `Root directory of your hardhat-ignition project`,
+//     undefined,
+//     types.string,
+//   )
+//   .addParam(
+//     "outDir",
+//     `Build output directory to place deployment info`,
+//     undefined,
+//     types.string,
+//   )
+//   .setAction(async (taskArgs, hre) => {
+//     await copyDeployments(taskArgs.rootDir, taskArgs.outDir);
+//   });
+// export async function copyDeployments(
+//   rootDir: string,
+//   outDir: string,
+// ): Promise<void> {
+//   const deploymentDir = path.resolve(rootDir, "src", "ignition", "deployments");
+//   const deployments = await listDeployments(deploymentDir);
+
+//   const allDeployments: Record<string, Record<string, string>> = {};
+//   for (const deployment of deployments) {
+//     const deployedAddressesPath = path.join(
+//       deploymentDir,
+//       deployment,
+//       "deployed_addresses.json",
+//     );
+//     allDeployments[deployment] = JSON.parse(
+//       fs.readFileSync(deployedAddressesPath, "utf8"),
+//     );
+//   }
+//   const outputTs = `export default ${
+//     JSON.stringify(allDeployments, null, 2)
+//   } as const;`;
+
+//   const deploymentsOutput = path.join(outDir, "deployments");
+//   if (!fs.existsSync(deploymentsOutput)) {
+//     fs.mkdirSync(deploymentsOutput, { recursive: true });
+//   }
+
+//   // ESM file
+//   {
+//     const result = ts.transpileModule(outputTs, {
+//       compilerOptions: {
+//         module: ts.ModuleKind.ESNext, // ESM
+//         target: ts.ScriptTarget.ESNext,
+//       },
+//     });
+//     fs.writeFileSync(
+//       path.join(deploymentsOutput, `index.mjs`),
+//       result.outputText,
+//       { flag: "w" },
+//     );
+//   }
+//   // CJS file
+//   {
+//     const result = ts.transpileModule(outputTs, {
+//       compilerOptions: {
+//         module: ts.ModuleKind.NodeNext, // CJS
+//         target: ts.ScriptTarget.ESNext,
+//       },
+//     });
+//     fs.writeFileSync(
+//       path.join(deploymentsOutput, `index.cjs`),
+//       result.outputText,
+//       { flag: "w" },
+//     );
+//   }
+//   // DTS file
+//   {
+//     /**
+//      * I couldn't find a nice way to convert a TS file to a d.ts file in-memory using the official typescript compiler API
+//      * since all the standard ways require a bunch of ugly file system operations.
+//      *
+//      * I found two ways to get this to work properly:
+//      * 1. Use `ts-morph` which is a typescript compiler wrapper that does support in-memory operations
+//      *    The problem is that it can block upgrading typescript since the ts-morph version needs to match your ts version
+//      * 2. Use `dts-dom` to manually construct the d.ts file as it's fairly simple
+//      *
+//      * I went with option 2
+//      */
+
+//     /**
+//      * This is the unused option (1) in case we ever end up needing it (ex: we need to do imports or other things not easily supported in dts-dom
+//      */
+//     // import tsMorph from 'ts-morph';
+//     //
+//     // const project = new tsMorph.Project({
+//     //     useInMemoryFileSystem: true,
+//     //     compilerOptions: {
+//     //         module: tsMorph.ModuleKind.ESNext,
+//     //         target: tsMorph.ScriptTarget.ESNext,
+//     //         declaration: true,
+//     //     },
+//     // });
+//     // const myClassFile = project.createSourceFile('deployment.ts', outputTs);
+//     // const emitResult = project.emitToMemory({ emitOnlyDtsFiles: true });
+//     // const declaration = emitResult.getFiles()[0].text;
+//     // fs.writeFileSync(path.join(deploymentsOutput, `index.d.ts`), declaration, { flag: 'w' });
+
+//     const changeCase = await import("change-case"); // async import since it's an ESM module, and Hardhat only supports CJS
+//     const file: string[] = [];
+
+//     const genType = (name: string, properties: dom.PropertyDeclaration[]) => {
+//       const type = dom.create.objectType(properties);
+//       const alias = dom.create.alias(changeCase.pascalCase(name), type);
+
+//       return alias;
+//     };
+//     const topLevelProperties: dom.PropertyDeclaration[] = [];
+//     for (const [deploymentName, contracts] of Object.entries(allDeployments)) {
+//       const type = genType(
+//         changeCase.pascalCase(deploymentName),
+//         Object.entries(contracts).map(
+//           ([contractName, contractAddress]) =>
+//             dom.create.property(
+//               contractName,
+//               dom.type.stringLiteral(contractAddress),
+//             ),
+//         ),
+//       );
+//       file.push(dom.emit(type));
+//       topLevelProperties.push(dom.create.property(deploymentName, type));
+//     }
+//     const topLevelType = genType(
+//       "DeployedContracts",
+//       topLevelProperties,
+//     );
+//     file.push(dom.emit(topLevelType));
+
+//     const topLevelConst = dom.create.const("_default", topLevelType);
+//     file.push(dom.emit(topLevelConst));
+//     const defaultExport = dom.create.exportDefault(topLevelConst.name);
+//     file.push(dom.emit(defaultExport));
+//     const dtsContent = file.join("\n");
+
+//     fs.writeFileSync(path.join(deploymentsOutput, `index.d.ts`), dtsContent, {
+//       flag: "w",
+//     });
+//   }
+// }
+
+// let name = dom.create.property("name", dom.type.string);
+// let age = dom.create.property("age", dom.type.number);
+// let type = dom.create.objectType([name, age]);
+// let typeBase = dom.create.alias("typeBase", type);

package/src/plugin/mod.ts

@@ -0,0 +1,6 @@
+// TODO: all this has to be updated to Hardhat v3
+
+// import "./paimaL2.js";
+// import "./deployment.js";
+// export * from "./recommendedHardhat.js";
+// export * from "./deployment.js";