@elizaos/autonomous 2.0.0-alpha.71 → 2.0.0-alpha.72

package/test/contracts/lib/openzeppelin-contracts/CODE_OF_CONDUCT.md

@@ -1,73 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as
-contributors and maintainers pledge to making participation in our project and
-our community a harassment-free experience for everyone, regardless of age, body
-size, disability, ethnicity, sex characteristics, gender identity and expression,
-level of experience, education, socio-economic status, nationality, personal
-appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment
-include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or
-  advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
-  address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
-  professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable
-behavior and are expected to take appropriate and fair corrective action in
-response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or
-reject comments, commits, code, wiki edits, issues, and other contributions
-that are not aligned to this Code of Conduct, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community. Examples of
-representing a project or community include using an official project e-mail
-address, posting via an official social media account, or acting as an appointed
-representative at an online or offline event. Representation of a project may be
-further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting the project team at contact@openzeppelin.com. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. The project team is
-obligated to maintain confidentiality with regard to the reporter of an incident.
-Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good
-faith may face temporary or permanent repercussions as determined by other
-members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
-available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
-
-[homepage]: https://www.contributor-covenant.org

package/test/contracts/lib/openzeppelin-contracts/CONTRIBUTING.md

@@ -1,36 +0,0 @@
-# Contributing Guidelines
-
-There are many ways to contribute to OpenZeppelin Contracts.
-
-## Troubleshooting
-
-You can help other users in the community to solve their smart contract issues in the [OpenZeppelin Forum].
-
-[OpenZeppelin Forum]: https://forum.openzeppelin.com/
-
-## Opening an issue
-
-You can [open an issue] to suggest a feature or report a minor bug. For serious bugs please do not open an issue, instead refer to our [security policy] for appropriate steps.
-
-If you believe your issue may be due to user error and not a problem in the library, consider instead posting a question on the [OpenZeppelin Forum].
-
-Before opening an issue, be sure to search through the existing open and closed issues, and consider posting a comment in one of those instead.
-
-When requesting a new feature, include as many details as you can, especially around the use cases that motivate it. Features are prioritized according to the impact they may have on the ecosystem, so we appreciate information showing that the impact could be high.
-
-[security policy]: https://github.com/OpenZeppelin/openzeppelin-contracts/security
-[open an issue]: https://github.com/OpenZeppelin/openzeppelin-contracts/issues/new/choose
-
-## Submitting a pull request
-
-If you would like to contribute code or documentation you may do so by forking the repository and submitting a pull request.
-
-Any non-trivial code contribution must be first discussed with the maintainers in an issue (see [Opening an issue](#opening-an-issue)). Only very minor changes are accepted without prior discussion.
-
-Make sure to read and follow the [engineering guidelines](./GUIDELINES.md). Run linter and tests to make sure your pull request is good before submitting it.
-
-Changelog entries should be added to each pull request by using [Changesets](https://github.com/changesets/changesets/).
-
-When opening the pull request you will be presented with a template and a series of instructions. Read through it carefully and follow all the steps. Expect a review and feedback from the maintainers afterwards.
-
-If you're looking for a good place to start, look for issues labelled ["good first issue"](https://github.com/OpenZeppelin/openzeppelin-contracts/labels/good%20first%20issue)!

package/test/contracts/lib/openzeppelin-contracts/GUIDELINES.md

@@ -1,117 +0,0 @@
-# Engineering Guidelines
-
-## Testing
-
-Code must be thoroughly tested with quality unit tests.
-
-We defer to the [Moloch Testing Guide](https://github.com/MolochVentures/moloch/tree/master/test#readme) for specific recommendations, though not all of it is relevant here. Note the introduction:
-
-> Tests should be written, not only to verify correctness of the target code, but to be comprehensively reviewed by other programmers. Therefore, for mission critical Solidity code, the quality of the tests are just as important (if not more so) than the code itself, and should be written with the highest standards of clarity and elegance.
-
-Every addition or change to the code must come with relevant and comprehensive tests.
-
-Refactors should avoid simultaneous changes to tests.
-
-Flaky tests are not acceptable.
-
-The test suite should run automatically for every change in the repository, and in pull requests tests must pass before merging.
-
-The test suite coverage must be kept as close to 100% as possible, enforced in pull requests.
-
-In some cases unit tests may be insufficient and complementary techniques should be used:
-
-1. Property-based tests (aka. fuzzing) for math-heavy code.
-2. Formal verification for state machines.
-
-## Code style
-
-Solidity code should be written in a consistent format enforced by a linter, following the official [Solidity Style Guide](https://docs.soliditylang.org/en/latest/style-guide.html). See below for further [Solidity Conventions](#solidity-conventions).
-
-The code should be simple and straightforward, prioritizing readability and understandability. Consistency and predictability should be maintained across the codebase. In particular, this applies to naming, which should be systematic, clear, and concise.
-
-Sometimes these guidelines may be broken if doing so brings significant efficiency gains, but explanatory comments should be added.
-
-Modularity should be pursued, but not at the cost of the above priorities.
-
-## Documentation
-
-For contributors, project guidelines and processes must be documented publicly.
-
-For users, features must be abundantly documented. Documentation should include answers to common questions, solutions to common problems, and recommendations for critical decisions that the user may face.
-
-All changes to the core codebase (excluding tests, auxiliary scripts, etc.) must be documented in a changelog, except for purely cosmetic or documentation changes.
-
-## Peer review
-
-All changes must be submitted through pull requests and go through peer code review.
-
-The review must be approached by the reviewer in a similar way as if it was an audit of the code in question (but importantly it is not a substitute for and should not be considered an audit).
-
-Reviewers should enforce code and project guidelines.
-
-External contributions must be reviewed separately by multiple maintainers.
-
-## Automation
-
-Automation should be used as much as possible to reduce the possibility of human error and forgetfulness.
-
-Automations that make use of sensitive credentials must use secure secret management, and must be strengthened against attacks such as [those on GitHub Actions worklows](https://github.com/nikitastupin/pwnhub).
-
-Some other examples of automation are:
-
-- Looking for common security vulnerabilities or errors in our code (eg. reentrancy analysis).
-- Keeping dependencies up to date and monitoring for vulnerable dependencies.
-
-## Pull requests
-
-Pull requests are squash-merged to keep the `master` branch history clean. The title of the pull request becomes the commit message, so it should be written in a consistent format:
-
-1) Begin with a capital letter.
-2) Do not end with a period.
-3) Write in the imperative: "Add feature X" and not "Adds feature X" or "Added feature X".
-
-This repository does not follow conventional commits, so do not prefix the title with "fix:" or "feat:".
-
-Work in progress pull requests should be submitted as Drafts and should not be prefixed with "WIP:".
-
-Branch names don't matter, and commit messages within a pull request mostly don't matter either, although they can help the review process.
-
-# Solidity Conventions
-
-In addition to the official Solidity Style Guide we have a number of other conventions that must be followed.
-
-* All state variables should be private.
-
-  Changes to state should be accompanied by events, and in some cases it is not correct to arbitrarily set state. Encapsulating variables as private and only allowing modification via setters enables us to ensure that events and other rules are followed reliably and prevents this kind of user error.
-
-* Internal or private state variables or functions should have an underscore prefix.
-
-  ```solidity
-  contract TestContract {
-      uint256 private _privateVar;
-      uint256 internal _internalVar;
-      function _testInternal() internal { ... }
-      function _testPrivate() private { ... }
-  }
-  ```
-
-* Events should be emitted immediately after the state change that they
-  represent, and should be named in the past tense.
-
-  ```solidity
-  function _burn(address who, uint256 value) internal {
-      super._burn(who, value);
-      emit TokensBurned(who, value);
-  }
-  ```
-
-  Some standards (e.g. ERC20) use present tense, and in those cases the
-  standard specification is used.
-  
-* Interface names should have a capital I prefix.
-
-  ```solidity
-  interface IERC777 {
-  ```
-
-* Unchecked arithmetic blocks should contain comments explaining why overflow is guaranteed not to happen. If the reason is immediately apparent from the line above the unchecked block, the comment may be omitted.

package/test/contracts/lib/openzeppelin-contracts/LICENSE

@@ -1,22 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2016-2023 zOS Global Limited and contributors
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be included
-in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/test/contracts/lib/openzeppelin-contracts/README.md

@@ -1,90 +0,0 @@
-# <img src="logo.svg" alt="OpenZeppelin" height="40px">
-
-[![NPM Package](https://img.shields.io/npm/v/@openzeppelin/contracts.svg)](https://www.npmjs.org/package/@openzeppelin/contracts)
-[![Coverage Status](https://codecov.io/gh/OpenZeppelin/openzeppelin-contracts/graph/badge.svg)](https://codecov.io/gh/OpenZeppelin/openzeppelin-contracts)
-[![GitPOAPs](https://public-api.gitpoap.io/v1/repo/OpenZeppelin/openzeppelin-contracts/badge)](https://www.gitpoap.io/gh/OpenZeppelin/openzeppelin-contracts)
-[![Docs](https://img.shields.io/badge/docs-%F0%9F%93%84-yellow)](https://docs.openzeppelin.com/contracts)
-[![Forum](https://img.shields.io/badge/forum-%F0%9F%92%AC-yellow)](https://docs.openzeppelin.com/contracts)
-
-**A library for secure smart contract development.** Build on a solid foundation of community-vetted code.
-
- * Implementations of standards like [ERC20](https://docs.openzeppelin.com/contracts/erc20) and [ERC721](https://docs.openzeppelin.com/contracts/erc721).
- * Flexible [role-based permissioning](https://docs.openzeppelin.com/contracts/access-control) scheme.
- * Reusable [Solidity components](https://docs.openzeppelin.com/contracts/utilities) to build custom contracts and complex decentralized systems.
-
-:mage: **Not sure how to get started?** Check out [Contracts Wizard](https://wizard.openzeppelin.com/) — an interactive smart contract generator.
-
-:building_construction: **Want to scale your decentralized application?** Check out [OpenZeppelin Defender](https://openzeppelin.com/defender) — a secure platform for automating and monitoring your operations.
-
-## Overview
-
-### Installation
-
-```
-$ npm install @openzeppelin/contracts
-```
-
-OpenZeppelin Contracts features a [stable API](https://docs.openzeppelin.com/contracts/releases-stability#api-stability), which means that your contracts won't break unexpectedly when upgrading to a newer minor version.
-
-An alternative to npm is to use the GitHub repository (`openzeppelin/openzeppelin-contracts`) to retrieve the contracts. When doing this, make sure to specify the tag for a release such as `v4.5.0`, instead of using the `master` branch.
-
-### Usage
-
-Once installed, you can use the contracts in the library by importing them:
-
-```solidity
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
-
-contract MyCollectible is ERC721 {
-    constructor() ERC721("MyCollectible", "MCO") {
-    }
-}
-```
-
-_If you're new to smart contract development, head to [Developing Smart Contracts](https://docs.openzeppelin.com/learn/developing-smart-contracts) to learn about creating a new project and compiling your contracts._
-
-To keep your system secure, you should **always** use the installed code as-is, and neither copy-paste it from online sources nor modify it yourself. The library is designed so that only the contracts and functions you use are deployed, so you don't need to worry about it needlessly increasing gas costs.
-
-## Learn More
-
-The guides in the [documentation site](https://docs.openzeppelin.com/contracts) will teach about different concepts, and how to use the related contracts that OpenZeppelin Contracts provides:
-
-* [Access Control](https://docs.openzeppelin.com/contracts/access-control): decide who can perform each of the actions on your system.
-* [Tokens](https://docs.openzeppelin.com/contracts/tokens): create tradeable assets or collectives, and distribute them via [Crowdsales](https://docs.openzeppelin.com/contracts/crowdsales).
-* [Utilities](https://docs.openzeppelin.com/contracts/utilities): generic useful tools including non-overflowing math, signature verification, and trustless paying systems.
-
-The [full API](https://docs.openzeppelin.com/contracts/api/token/ERC20) is also thoroughly documented, and serves as a great reference when developing your smart contract application. You can also ask for help or follow Contracts's development in the [community forum](https://forum.openzeppelin.com).
-
-Finally, you may want to take a look at the [guides on our blog](https://blog.openzeppelin.com/guides), which cover several common use cases and good practices. The following articles provide great background reading, though please note that some of the referenced tools have changed, as the tooling in the ecosystem continues to rapidly evolve.
-
-* [The Hitchhiker’s Guide to Smart Contracts in Ethereum](https://blog.openzeppelin.com/the-hitchhikers-guide-to-smart-contracts-in-ethereum-848f08001f05) will help you get an overview of the various tools available for smart contract development, and help you set up your environment.
-* [A Gentle Introduction to Ethereum Programming, Part 1](https://blog.openzeppelin.com/a-gentle-introduction-to-ethereum-programming-part-1-783cc7796094) provides very useful information on an introductory level, including many basic concepts from the Ethereum platform.
-* For a more in-depth dive, you may read the guide [Designing the Architecture for Your Ethereum Application](https://blog.openzeppelin.com/designing-the-architecture-for-your-ethereum-application-9cec086f8317), which discusses how to better structure your application and its relationship to the real world.
-
-## Security
-
-This project is maintained by [OpenZeppelin](https://openzeppelin.com) with the goal of providing a secure and reliable library of smart contract components for the ecosystem. We address security through risk management in various areas such as engineering and open source best practices, scoping and API design, multi-layered review processes, and incident response preparedness.
-
-The security policy is detailed in [`SECURITY.md`](./SECURITY.md), and specifies how you can report security vulnerabilities, which versions will receive security patches, and how to stay informed about them. We run a [bug bounty program on Immunefi](https://immunefi.com/bounty/openzeppelin) to reward the responsible disclosure of vulnerabilities.
-
-The engineering guidelines we follow to promote project quality can be found in [`GUIDELINES.md`](./GUIDELINES.md).
-
-Past audits can be found in [`audits/`](./audits).
-
-Smart contracts are a nascent technology and carry a high level of technical risk and uncertainty. Although OpenZeppelin is well known for its security audits, using OpenZeppelin Contracts is not a substitute for a security audit.
-
-OpenZeppelin Contracts is made available under the MIT License, which disclaims all warranties in relation to the project and which limits the liability of those that contribute and maintain the project, including OpenZeppelin. As set out further in the Terms, you acknowledge that you are solely responsible for any use of OpenZeppelin Contracts and you assume all risks associated with any such use.
-
-## Contribute
-
-OpenZeppelin Contracts exists thanks to its contributors. There are many ways you can participate and help build high quality software. Check out the [contribution guide](CONTRIBUTING.md)!
-
-## License
-
-OpenZeppelin Contracts is released under the [MIT License](LICENSE).
-
-## Legal
-
-Your use of this Project is governed by the terms found at www.openzeppelin.com/tos (the "Terms").

package/test/contracts/lib/openzeppelin-contracts/RELEASING.md

@@ -1,47 +0,0 @@
-# Releasing
-
-> Visit the documentation for [details about release schedule](https://docs.openzeppelin.com/contracts/releases-stability).
-
-OpenZeppelin Contracts uses a fully automated release process that takes care of compiling, packaging, and publishing the library, all of which is carried out in a clean CI environment (GitHub Actions), implemented in the ([`release-cycle`](.github/workflows/release-cycle.yml)) workflow. This helps to reduce the potential for human error and inconsistencies, and ensures that the release process is ongoing and reliable.
-
-## Changesets
-
-[Changesets](https://github.com/changesets/changesets/) is used as part of our release process for `CHANGELOG.md` management. Each change that is relevant for the codebase is expected to include a changeset.
-
-## Branching model
-
-The release cycle happens on release branches called `release-vX.Y`. Each of these branches starts as a release candidate (rc) and is eventually promoted to final.
-
-A release branch can be updated with cherry-picked patches from `master`, or may sometimes be committed to directly in the case of old releases. These commits will lead to a new release candidate or a patch increment depending on the state of the release branch.
-
-```mermaid
-  %%{init: {'gitGraph': {'mainBranchName': 'master'}} }%%
-  gitGraph
-    commit id: "Feature A"
-    commit id: "Feature B"
-    branch release-vX.Y
-    commit id: "Start release"
-    commit id: "Release vX.Y.0-rc.0"
-
-    checkout master
-    commit id: "Feature C"
-    commit id: "Fix A"
-
-    checkout release-vX.Y
-    cherry-pick id: "Fix A" tag: ""
-    commit id: "Release vX.Y.0-rc.1"
-    commit id: "Release vX.Y.0"
-
-    checkout master
-    merge release-vX.Y
-    commit id: "Feature D"
-    commit id: "Patch B"
-
-    checkout release-vX.Y
-    cherry-pick id: "Patch B" tag: ""
-    commit id: "Release vX.Y.1"
-    
-    checkout master
-    merge release-vX.Y
-    commit id: "Feature E"
-```

package/test/contracts/lib/openzeppelin-contracts/SECURITY.md

@@ -1,42 +0,0 @@
-# Security Policy
-
-Security vulnerabilities should be disclosed to the project maintainers through [Immunefi], or alternatively by email to security@openzeppelin.com.
-
-[Immunefi]: https://immunefi.com/bounty/openzeppelin
-
-## Bug Bounty
-
-Responsible disclosure of security vulnerabilities is rewarded through a bug bounty program on [Immunefi].
-
-There is a bonus reward for issues introduced in release candidates that are reported before making it into a stable release.
-
-## Security Patches
-
-Security vulnerabilities will be patched as soon as responsibly possible, and published as an advisory on this repository (see [advisories]) and on the affected npm packages.
-
-[advisories]: https://github.com/OpenZeppelin/openzeppelin-contracts/security/advisories
-
-Projects that build on OpenZeppelin Contracts are encouraged to clearly state, in their source code and websites, how to be contacted about security issues in the event that a direct notification is considered necessary. We recommend including it in the NatSpec for the contract as `/// @custom:security-contact security@example.com`.
-
-Additionally, we recommend installing the library through npm and setting up vulnerability alerts such as [Dependabot].
-
-[Dependabot]: https://docs.github.com/en/code-security/supply-chain-security/understanding-your-software-supply-chain/about-supply-chain-security#what-is-dependabot
-
-### Supported Versions
-
-Security patches will be released for the latest minor of a given major release. For example, if an issue is found in versions >=4.6.0 and the latest is 4.8.0, the patch will be released only in version 4.8.1.
-
-Only critical severity bug fixes will be backported to past major releases.
-
-| Version | Critical security fixes | Other security fixes |
-| ------- | ----------------------- | -------------------- |
-| 4.x     | :white_check_mark:      | :white_check_mark:   |
-| 3.4     | :white_check_mark:      | :x:                  |
-| 2.5     | :white_check_mark:      | :x:                  |
-| < 2.0   | :x:                     | :x:                  |
-
-Note as well that the Solidity language itself only guarantees security updates for the latest release.
-
-## Legal
-
-Smart contracts are a nascent techology and carry a high level of technical risk and uncertainty.  OpenZeppelin Contracts is made available under the MIT License, which disclaims all warranties in relation to the project and which limits the liability of those that contribute and maintain the project, including OpenZeppelin. Your use of the project is also governed by the terms found at www.openzeppelin.com/tos (the "Terms"). As set out in the Terms, you are solely responsible for any use of OpenZeppelin Contracts and you assume all risks associated with any such use. This Security Policy in no way evidences or represents an on-going duty by any contributor, including OpenZeppelin, to correct any flaws or alert you to all or any of the potential risks of utilizing the project.