@paimaexample/evm-contracts 0.3.0

package/src/plugin/paimaL2.ts

@@ -0,0 +1,202 @@
+// import { task, types } from 'hardhat/config';
+// import '@nomicfoundation/hardhat-toolbox-viem';
+// import { getContract, getOrAskString, ownerCheck, paimaScope } from './common.js';
+// import { decodeAbiParameters } from 'viem';
+// import { stringToBytes } from 'viem';
+
+// paimaScope
+//   .task('PaimaL2Contract:setFee', `Sets the fee of a Paima L2 contract`)
+//   .addOptionalParam('contract', `The contracts's address`, undefined, types.string)
+//   .addOptionalParam('fee', `The new fee (wei)`, undefined, types.string)
+//   .setAction(async (taskArgs, hre) => {
+//     const publicClient = await hre.viem.getPublicClient();
+//     // Connect to the deployed contract
+//     const { signer, account } = await getContract(hre, taskArgs.contract);
+//     const contract = await hre.viem.getContractAt('PaimaL2Contract', account);
+
+//     ownerCheck((await contract.read.owner()) as string, await signer.account!.address);
+
+//     const newFee = BigInt(await getOrAskString(taskArgs.fee, 'Fee? '));
+//     if ((await contract.read.fee()) === newFee) {
+//       console.log(`Fee matches existing value "${newFee}". Skipping`);
+//       return;
+//     }
+//     const hash = await contract.write.setFee([newFee]);
+//     await publicClient.waitForTransactionReceipt({ hash });
+//     const updatedValue = await contract.read.fee();
+//     console.log(`The updated value of "fee" is: ${updatedValue}`);
+//   });
+// paimaScope
+//   .task('PaimaL2Contract:setOwner', `Sets the owner of a Paima L2 contract`)
+//   .addOptionalParam('contract', `The contracts's address`, undefined, types.string)
+//   .addOptionalParam('owner', `The new owner address`, undefined, types.string)
+//   .setAction(async (taskArgs, hre) => {
+//     const publicClient = await hre.viem.getPublicClient();
+//     // Connect to the deployed contract
+//     const { signer, account } = await getContract(hre, taskArgs.contract);
+//     const contract = await hre.viem.getContractAt('PaimaL2Contract', account);
+
+//     ownerCheck((await contract.read.owner()) as string, await signer.account!.address);
+
+//     if ((await contract.read.owner()) === taskArgs.owner) {
+//       console.log(`Owner matches existing value "${taskArgs.owner}". Skipping`);
+//       return;
+//     }
+//     const hash = await contract.write.setOwner([taskArgs.owner]);
+//     await publicClient.waitForTransactionReceipt({ hash });
+//     const updatedValue = await contract.read.owner();
+//     console.log(`The updated value of "owner" is: ${updatedValue}`);
+//   });
+
+// paimaScope
+//   .task('PaimaL2Contract:withdrawFunds', `Withdraws funds out of the Paima L2 contract`)
+//   .addOptionalParam('contract', `The contracts's address`, undefined, types.string)
+//   .setAction(async (taskArgs, hre) => {
+//     const publicClient = await hre.viem.getPublicClient();
+//     // Connect to the deployed contract
+//     const { signer, account } = await getContract(hre, taskArgs.contract);
+//     const contract = await hre.viem.getContractAt('PaimaL2Contract', account);
+
+//     ownerCheck((await contract.read.owner()) as string, await signer.account!.address);
+
+//     const currentBalance = await publicClient.getBalance({
+//       address: account,
+//     });
+//     if (currentBalance === 0n) {
+//       console.log(`Current balance is "${0n}". Skipping`);
+//       return;
+//     }
+//     const hash = await contract.write.withdrawFunds();
+//     await publicClient.waitForTransactionReceipt({ hash });
+//     console.log(`Withdrew ${currentBalance} to ${await signer.account!.address}`);
+//   });
+
+// paimaScope
+//   .task('PaimaL2Contract:submitGameInput', `Submit data to the Paima L2 contract`)
+//   .addOptionalParam('contract', `The contracts's address`, undefined, types.string)
+//   .addOptionalParam(
+//     'data',
+//     `The data to submit either hex-encoded (0x...) or Paima concise-encoded`,
+//     undefined,
+//     types.string
+//   )
+//   .setAction(async (taskArgs, hre) => {
+//     const publicClient = await hre.viem.getPublicClient();
+//     // Connect to the deployed contract
+//     const { signer, account } = await getContract(hre, taskArgs.contract);
+//     const contract = await hre.viem.getContractAt('PaimaL2Contract', account);
+
+//     const providedData = await getOrAskString(taskArgs.data, 'data? ');
+//     const data = providedData.startsWith('0x') ? providedData : stringToBytes(providedData);
+
+//     const fee = await contract.read.fee();
+//     console.log(fee);
+//     const hash = await contract.write.paimaSubmitGameInput([data], { value: fee });
+//     await publicClient.waitForTransactionReceipt({ hash });
+//     console.log(`Submitted data to the contract successfully at ${hash}`);
+//   });
+
+// paimaScope
+//   .task('PaimaL2Contract:recentInputs', `Gets data recently submitted to the Paima L2 contract`)
+//   .addOptionalParam('contract', `The contracts's address`, undefined, types.string)
+//   .addOptionalParam(
+//     'data',
+//     `The data to submit in hex-encoded for (0x...)`,
+//     undefined,
+//     types.string
+//   )
+//   .addOptionalParam(
+//     'range',
+//     `How far back to get events (default: look back 1000 blocks from tip)`,
+//     undefined,
+//     types.int
+//   )
+//   .setAction(async (taskArgs, hre) => {
+//     // Connect to the deployed contract
+//     const { account } = await getContract(hre, taskArgs.contract);
+
+//     const publicClient = await hre.viem.getPublicClient();
+
+//     const contract = await hre.viem.getContractAt('PaimaL2Contract', account);
+
+//     const toBlock = await publicClient.getBlockNumber();
+//     const maxRange = taskArgs.range ?? 10000n;
+//     const fromBlock = maxRange > toBlock ? 0n : toBlock - maxRange;
+
+//     const eventFilter = await contract.createEventFilter.PaimaGameInteraction({
+//       fromBlock,
+//       toBlock,
+//     });
+//     const events = await publicClient.getFilterLogs({
+//       filter: eventFilter,
+//     });
+
+//     const getData = (rawData: `0x${string}`): string => {
+//       const tentativeData = decodeAbiParameters([{ type: 'bytes' }], rawData)[0] as string;
+//       const textBuffer = Buffer.from(tentativeData.substring('0x'.length), 'hex');
+//       try {
+//         const decoded = new TextDecoder('utf-8', { fatal: true }).decode(textBuffer);
+//         // check if ASCII data
+//         if (/^[\x20-\x7E]*$/.test(decoded)) {
+//           return decoded;
+//         }
+//         // cannot be printed in a terminal
+//         return tentativeData;
+//       } catch (e) {
+//         // not a valid utf8 string
+//         return tentativeData;
+//       }
+//     };
+
+//     console.log(
+//       events.map(event => ({
+//         blockHash: event.blockHash,
+//         blockNumber: event.blockNumber,
+//         transactionHash: event.transactionHash,
+//         address: event.address,
+//         data: getData(event.data),
+//       }))
+//     );
+//   });
+
+// task('genDocs', `Generate documentation for tasks of a given scope`)
+//   .addParam('scope', 'The scope to generate documentation for')
+//   .setAction(async ({ scope }, hre) => {
+//     const scopeContent = hre.scopes[scope];
+//     console.log(scopeContent);
+
+//     console.log(`# ${scopeContent.description ?? scope}`);
+//     console.log(
+//       `These are all the [hardhat tasks](https://hardhat.org/hardhat-runner/docs/advanced/create-task) available for the scope \`${scope}\`.`
+//     );
+//     console.log();
+//     console.log(`You can call each of these tasks using \`npx hardhat ${scope} task_name\``);
+//     for (const [name, definition] of Object.entries(scopeContent.tasks)) {
+//       console.log();
+//       console.log(`## \`${name}\``);
+//       console.log(definition.description ?? 'No description provided');
+//       const parameters = Object.values(definition.paramDefinitions);
+//       if (parameters.length > 0) {
+//         console.log();
+//         console.log('Parameters:');
+//         for (const param of parameters) {
+//           let annotations = [];
+//           if (param.isOptional) {
+//             annotations.push(`optional`);
+//             if (param.defaultValue != null) {
+//               annotations.push(`${param.defaultValue}`);
+//             }
+//           }
+//           if (param.type) {
+//             annotations.push(`${param.type.name}`);
+//           }
+//           const annotationText = annotations.length > 0 ? ` *(${annotations.join(', ')})* ` : '';
+//           console.log(
+//             `- **${param.name}**${annotationText}: ${
+//               param.description ?? 'No description provided'
+//             }`
+//           );
+//         }
+//       }
+//     }
+//   });

package/src/recommendedHardhat.ts

@@ -0,0 +1,86 @@
+import type { HardhatUserConfig } from "hardhat/config";
+import HardhatViem from "@nomicfoundation/hardhat-viem";
+// import "hardhat-interact";
+// import HardhatAbiExporter from "hardhat-abi-exporter";
+
+export function defaultHardhatConfig(config: {
+  outDir: string;
+}): HardhatUserConfig {
+  const defaultConfig: HardhatUserConfig = {
+    paths: {
+      sources: "./src/contracts",
+      tests: "./test/src",
+      cache: `${config.outDir}/cache/hardhat`,
+      artifacts: `${config.outDir}/artifacts/hardhat`,
+      // ignition: "./src/ignition",
+    },
+    tasks: [],
+    plugins: [
+      HardhatViem,
+      // HardhatAbiExporter,
+    ],
+    solidity: {
+      version: "0.8.22",
+      dependenciesToCompile: [],
+      // remappings: [
+      //   "remapped/=npm/@openzeppelin/contracts@5.1.0/access/",
+      //   // This is necessary because most people import forge-std/Test.sol, and not forge-std/src/Test.sol
+      //   "forge-std/=npm/forge-std@local/src/",
+      // ],
+    },
+    // abiExporter: {
+    //   path: `${config.outDir}/abi`,
+    //   runOnCompile: true,
+    //   tsWrapper: true,
+    //   clear: true,
+    //   flat: false,
+    // },
+  };
+
+  return defaultConfig;
+}
+
+// /**
+//  * This type comes from hardhat-ignition. It's unfortunately not exported
+//  */
+// type IgnitionDeployParameters = {
+//   modulePath: string;
+//   parameters?: string;
+//   deploymentId: string | undefined;
+//   defaultSender: string | undefined;
+//   reset: boolean;
+//   verify: boolean;
+//   strategy: string;
+//   writeLocalhostDeployment: boolean;
+// };
+
+// /**
+//  * TODO: this may be replaced by a built-in feature in the future
+//  * https://github.com/NomicFoundation/hardhat-ignition/issues/791
+//  */
+// export function defaultDeployment(
+//   rootDir: string,
+//   outDir: string,
+//   config: IgnitionDeployParameters
+// ): void {
+//   subtask(TASK_NODE_SERVER_READY, async (_, hre, runSuper) => {
+//     const result = await runSuper();
+
+//     await hre.run(
+//       {
+//         scope: 'ignition',
+//         task: 'deploy',
+//       },
+//       config
+//     );
+//     await hre.run(
+//       {
+//         scope: 'paima',
+//         task: 'copy-ignition-deployment',
+//       },
+//       { rootDir, outDir }
+//     );
+
+//     return result;
+//   });
+// }

package/test/lib/StdInvariant.sol

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.2 <0.9.0;
+
+pragma experimental ABIEncoderV2;
+
+abstract contract StdInvariant {
+    struct FuzzSelector {
+        address addr;
+        bytes4[] selectors;
+    }
+
+    address[] private _excludedContracts;
+    address[] private _excludedSenders;
+    address[] private _targetedContracts;
+    address[] private _targetedSenders;
+
+    string[] private _excludedArtifacts;
+    string[] private _targetedArtifacts;
+
+    FuzzSelector[] private _targetedArtifactSelectors;
+    FuzzSelector[] private _targetedSelectors;
+
+    // Functions for users:
+    // These are intended to be called in tests.
+
+    function excludeContract(address newExcludedContract_) internal {
+        _excludedContracts.push(newExcludedContract_);
+    }
+
+    function excludeSender(address newExcludedSender_) internal {
+        _excludedSenders.push(newExcludedSender_);
+    }
+
+    function excludeArtifact(string memory newExcludedArtifact_) internal {
+        _excludedArtifacts.push(newExcludedArtifact_);
+    }
+
+    function targetArtifact(string memory newTargetedArtifact_) internal {
+        _targetedArtifacts.push(newTargetedArtifact_);
+    }
+
+    function targetArtifactSelector(FuzzSelector memory newTargetedArtifactSelector_) internal {
+        _targetedArtifactSelectors.push(newTargetedArtifactSelector_);
+    }
+
+    function targetContract(address newTargetedContract_) internal {
+        _targetedContracts.push(newTargetedContract_);
+    }
+
+    function targetSelector(FuzzSelector memory newTargetedSelector_) internal {
+        _targetedSelectors.push(newTargetedSelector_);
+    }
+
+    function targetSender(address newTargetedSender_) internal {
+        _targetedSenders.push(newTargetedSender_);
+    }
+
+    // Functions for forge:
+    // These are called by forge to run invariant tests and don't need to be called in tests.
+
+    function excludeArtifacts() public view returns (string[] memory excludedArtifacts_) {
+        excludedArtifacts_ = _excludedArtifacts;
+    }
+
+    function excludeContracts() public view returns (address[] memory excludedContracts_) {
+        excludedContracts_ = _excludedContracts;
+    }
+
+    function excludeSenders() public view returns (address[] memory excludedSenders_) {
+        excludedSenders_ = _excludedSenders;
+    }
+
+    function targetArtifacts() public view returns (string[] memory targetedArtifacts_) {
+        targetedArtifacts_ = _targetedArtifacts;
+    }
+
+    function targetArtifactSelectors()
+        public
+        view
+        returns (FuzzSelector[] memory targetedArtifactSelectors_)
+    {
+        targetedArtifactSelectors_ = _targetedArtifactSelectors;
+    }
+
+    function targetContracts() public view returns (address[] memory targetedContracts_) {
+        targetedContracts_ = _targetedContracts;
+    }
+
+    function targetSelectors() public view returns (FuzzSelector[] memory targetedSelectors_) {
+        targetedSelectors_ = _targetedSelectors;
+    }
+
+    function targetSenders() public view returns (address[] memory targetedSenders_) {
+        targetedSenders_ = _targetedSenders;
+    }
+}

package/test/lib/cheatcodes.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.7;
+
+interface CheatCodes {
+    // Set block.timestamp (newTimestamp)
+    function warp(uint256) external;
+
+    // Set block.height (newHeight)
+    function roll(uint256) external;
+
+    // Set block.basefee (newBasefee)
+    function fee(uint256) external;
+
+    // Loads a storage slot from an address (who, slot)
+    function load(address, bytes32) external returns (bytes32);
+
+    // Stores a value to an address' storage slot, (who, slot, value)
+    function store(address, bytes32, bytes32) external;
+
+    // Signs data, (privateKey, digest) => (v, r, s)
+    function sign(uint256, bytes32) external returns (uint8, bytes32, bytes32);
+
+    // Gets address for a given private key, (privateKey) => (address)
+    function addr(uint256) external returns (address);
+
+    // Performs a foreign function call via terminal, (stringInputs) => (result)
+    function ffi(string[] calldata) external returns (bytes memory);
+
+    // Sets the *next* call's msg.sender to be the input address
+    function prank(address) external;
+
+    // Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called
+    function startPrank(address) external;
+
+    // Sets the *next* call's msg.sender to be the input address, and the tx.origin to be the second input
+    function prank(address, address) external;
+
+    // Sets all subsequent calls' msg.sender to be the input address until `stopPrank` is called, and the tx.origin to be the second input
+    function startPrank(address, address) external;
+
+    // Resets subsequent calls' msg.sender to be `address(this)`
+    function stopPrank() external;
+
+    // Sets an address' balance, (who, newBalance)
+    function deal(address, uint256) external;
+
+    // Sets an address' code, (who, newCode)
+    function etch(address, bytes calldata) external;
+
+    // Expects an error on next call
+    function expectRevert(bytes calldata) external;
+
+    function expectRevert(bytes4) external;
+
+    function expectRevert() external;
+
+    // Record all storage reads and writes
+    function record() external;
+
+    // Gets all accessed reads and write slot from a recording session, for a given address
+    function accesses(address) external returns (bytes32[] memory reads, bytes32[] memory writes);
+
+    // Prepare an expected log with (bool checkTopic1, bool checkTopic2, bool checkTopic3, bool checkData).
+    // Call this function, then emit an event, then call a function. Internally after the call, we check if
+    // logs were emitted in the expected order with the expected topics and data (as specified by the booleans)
+    function expectEmit(bool, bool, bool, bool) external;
+
+    // Mocks a call to an address, returning specified data.
+    // Calldata can either be strict or a partial match, e.g. if you only
+    // pass a Solidity selector to the expected calldata, then the entire Solidity
+    // function will be mocked.
+    function mockCall(address, bytes calldata, bytes calldata) external;
+
+    // Clears all mocked calls
+    function clearMockedCalls() external;
+
+    // Expect a call to an address with the specified calldata.
+    // Calldata can either be strict or a partial match
+    function expectCall(address, bytes calldata) external;
+
+    // Gets the code from an artifact file. Takes in the relative path to the json file
+    function getCode(string calldata) external returns (bytes memory);
+
+    // Labels an address in call traces
+    function label(address, string calldata) external;
+
+    // If the condition is false, discard this run's fuzz inputs and generate new ones.
+    function assume(bool condition) external pure;
+}