polkamarkets-js 3.4.1 → 3.4.3

package/lib/openzeppelin-contracts.git/docs/modules/ROOT/pages/utilities.adoc

@@ -1,190 +0,0 @@
-= Utilities
-
-The OpenZeppelin Contracts provide a ton of useful utilities that you can use in your project. Here are some of the more popular ones.
-
-[[cryptography]]
-== Cryptography
-
-=== Checking Signatures On-Chain
-
-xref:api:utils.adoc#ECDSA[`ECDSA`] provides functions for recovering and managing Ethereum account ECDSA signatures. These are often generated via https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#sign[`web3.eth.sign`], and are a 65 byte array (of type `bytes` in Solidity) arranged the following way: `[[v (1)], [r (32)], [s (32)]]`.
-
-The data signer can be recovered with xref:api:utils.adoc#ECDSA-recover-bytes32-bytes-[`ECDSA.recover`], and its address compared to verify the signature. Most wallets will hash the data to sign and add the prefix '\x19Ethereum Signed Message:\n', so when attempting to recover the signer of an Ethereum signed message hash, you'll want to use xref:api:utils.adoc#ECDSA-toEthSignedMessageHash-bytes32-[`toEthSignedMessageHash`].
-
-[source,solidity]
-----
-using ECDSA for bytes32;
-
-function _verify(bytes32 data, bytes memory signature, address account) internal pure returns (bool) {
-    return data
-        .toEthSignedMessageHash()
-        .recover(signature) == account;
-}
-----
-
-WARNING: Getting signature verification right is not trivial: make sure you fully read and understand xref:api:utils.adoc#ECDSA[`ECDSA`]'s documentation.
-
-=== Verifying Merkle Proofs
-
-xref:api:utils.adoc#MerkleProof[`MerkleProof`] provides:
-
-* xref:api:utils.adoc#MerkleProof-verify-bytes32---bytes32-bytes32-[`verify`] - can prove that some value is part of a https://en.wikipedia.org/wiki/Merkle_tree[Merkle tree].
-
-* xref:api:utils.adoc#MerkleProof-multiProofVerify-bytes32-bytes32---bytes32---bool---[`multiProofVerify`] - can prove multiple values are part of a Merkle tree.
-
-[[introspection]]
-== Introspection
-
-In Solidity, it's frequently helpful to know whether or not a contract supports an interface you'd like to use. ERC165 is a standard that helps do runtime interface detection. Contracts provide helpers both for implementing ERC165 in your contracts and querying other contracts:
-
-* xref:api:utils.adoc#IERC165[`IERC165`] — this is the ERC165 interface that defines xref:api:utils.adoc#IERC165-supportsInterface-bytes4-[`supportsInterface`]. When implementing ERC165, you'll conform to this interface.
-* xref:api:utils.adoc#ERC165[`ERC165`] — inherit this contract if you'd like to support interface detection using a lookup table in contract storage. You can register interfaces using xref:api:utils.adoc#ERC165-_registerInterface-bytes4-[`_registerInterface(bytes4)`]: check out example usage as part of the ERC721 implementation.
-* xref:api:utils.adoc#ERC165Checker[`ERC165Checker`] — ERC165Checker simplifies the process of checking whether or not a contract supports an interface you care about.
-* include with `using ERC165Checker for address;`
-* xref:api:utils.adoc#ERC165Checker-_supportsInterface-address-bytes4-[`myAddress._supportsInterface(bytes4)`]
-* xref:api:utils.adoc#ERC165Checker-_supportsAllInterfaces-address-bytes4---[`myAddress._supportsAllInterfaces(bytes4[\])`]
-
-[source,solidity]
-----
-contract MyContract {
-    using ERC165Checker for address;
-
-    bytes4 private InterfaceId_ERC721 = 0x80ac58cd;
-
-    /**
-     * @dev transfer an ERC721 token from this contract to someone else
-     */
-    function transferERC721(
-        address token,
-        address to,
-        uint256 tokenId
-    )
-        public
-    {
-        require(token.supportsInterface(InterfaceId_ERC721), "IS_NOT_721_TOKEN");
-        IERC721(token).transferFrom(address(this), to, tokenId);
-    }
-}
-----
-
-[[math]]
-== Math
-
-The most popular math related library OpenZeppelin Contracts provides is xref:api:utils.adoc#SafeMath[`SafeMath`], which provides mathematical functions that protect your contract from overflows and underflows.
-
-Include the contract with `using SafeMath for uint256;` and then call the functions:
-
-* `myNumber.add(otherNumber)`
-* `myNumber.sub(otherNumber)`
-* `myNumber.div(otherNumber)`
-* `myNumber.mul(otherNumber)`
-* `myNumber.mod(otherNumber)`
-
-Easy!
-
-[[payment]]
-== Payment
-
-Want to split some payments between multiple people? Maybe you have an app that sends 30% of art purchases to the original creator and 70% of the profits to the current owner; you can build that with xref:api:finance.adoc#PaymentSplitter[`PaymentSplitter`]!
-
-In Solidity, there are some security concerns with blindly sending money to accounts, since it allows them to execute arbitrary code. You can read up on these security concerns in the https://consensys.github.io/smart-contract-best-practices/[Ethereum Smart Contract Best Practices] website. One of the ways to fix reentrancy and stalling problems is, instead of immediately sending Ether to accounts that need it, you can use xref:api:security.adoc#PullPayment[`PullPayment`], which offers an xref:api:security.adoc#PullPayment-_asyncTransfer-address-uint256-[`_asyncTransfer`] function for sending money to something and requesting that they xref:api:security.adoc#PullPayment-withdrawPayments-address-payable-[`withdrawPayments()`] it later.
-
-If you want to Escrow some funds, check out xref:api:utils.adoc#Escrow[`Escrow`] and xref:api:utils.adoc#ConditionalEscrow[`ConditionalEscrow`] for governing the release of some escrowed Ether.
-
-[[collections]]
-== Collections
-
-If you need support for more powerful collections than Solidity's native arrays and mappings, take a look at xref:api:utils.adoc#EnumerableSet[`EnumerableSet`] and xref:api:utils.adoc#EnumerableMap[`EnumerableMap`]. They are similar to mappings in that they store and remove elements in constant time and don't allow for repeated entries, but they also support _enumeration_, which means you can easily query all stored entries both on and off-chain.
-
-[[misc]]
-== Misc
-
-Want to check if an address is a contract? Use xref:api:utils.adoc#Address[`Address`] and xref:api:utils.adoc#Address-isContract-address-[`Address.isContract()`].
-
-Want to keep track of some numbers that increment by 1 every time you want another one? Check out xref:api:utils.adoc#Counters[`Counters`]. This is useful for lots of things, like creating incremental identifiers, as shown on the xref:erc721.adoc[ERC721 guide].
-
-=== Base64
-
-xref:api:utils.adoc#Base64[`Base64`] util allows you to transform `bytes32` data into its Base64 `string` representation. 
-
-This is specially useful to build URL-safe tokenURIs for both xref:api:token/ERC721.adoc#IERC721Metadata-tokenURI-uint256-[`ERC721`] or xref:api:token/ERC1155.adoc#IERC1155MetadataURI-uri-uint256-[`ERC1155`]. This library provides a clever way to serve URL-safe https://developer.mozilla.org/docs/Web/HTTP/Basics_of_HTTP/Data_URIs/[Data URI] compliant strings to serve on-chain data structures.
-
-Consider this is an example to send JSON Metadata through a Base64 Data URI using an ERC721:
-
-[source, solidity]
-----
-// contracts/My721Token.sol
-// SPDX-License-Identifier: MIT
-
-import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
-import "@openzeppelin/contracts/utils/Strings.sol";
-import "@openzeppelin/contracts/utils/Base64.sol";
-
-contract My721Token is ERC721 {
-    using Strings for uint256;
-
-    constructor() ERC721("My721Token", "MTK") {}
-    
-    ...
-
-    function tokenURI(uint256 tokenId)
-        public
-        pure
-        override
-        returns (string memory)
-    {
-        bytes memory dataURI = abi.encodePacked(
-            '{',
-                '"name": "My721Token #', tokenId.toString(), '"',
-                // Replace with extra ERC721 Metadata properties
-            '}'
-        );
-
-        return string(
-            abi.encodePacked(
-                "data:application/json;base64,", 
-                Base64.encode(dataURI)
-            )
-        );
-    }
-}
-----
-
-=== Multicall
-
-The `Multicall` abstract contract comes with a `multicall` function that bundles together multiple calls in a single external call. With it, external accounts may perform atomic operations comprising several function calls. This is not only useful for EOAs to make multiple calls in a single transaction, it's also a way to revert a previous call if a later one fails.
-
-Consider this dummy contract:
-
-[source,solidity]
-----
-// contracts/Box.sol
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.0;
-
-import "@openzeppelin/contracts/utils/Multicall.sol";
-
-contract Box is Multicall {
-    function foo() public {
-        ...
-    }
-
-    function bar() public {
-        ...
-    }
-}
-----
-
-This is how to call the `multicall` function using Truffle, allowing `foo` and `bar` to be called in a single transaction:
-[source,javascript]
-----
-// scripts/foobar.js
-
-const Box = artifacts.require('Box');
-const instance = await Box.new();
-
-await instance.multicall([
-    instance.contract.methods.foo().encodeABI(),
-    instance.contract.methods.bar().encodeABI()
-]);
-----

package/lib/openzeppelin-contracts.git/docs/modules/ROOT/pages/wizard.adoc

@@ -1,15 +0,0 @@
-= Contracts Wizard
-:page-notoc:
-
-Not sure where to start? Use the interactive generator below to bootstrap your
-contract and learn about the components offered in OpenZeppelin Contracts.
-
-TIP: Place the resulting contract in your `contracts` directory in order to compile it with a tool like Hardhat or Truffle. Consider reading our guide on xref:learn::developing-smart-contracts.adoc[Developing Smart Contracts] for more guidance!
-
-++++
-<script async src="https://wizard.openzeppelin.com/build/embed.js"></script>
-
-<oz-wizard style="display: block; min-height: 40rem;"></oz-wizard>
-++++
-
-

package/lib/openzeppelin-contracts.git/docs/templates/contract.hbs

@@ -1,85 +0,0 @@
-{{#each items}}
-:{{name}}: pass:normal[xref:#{{anchor}}[`++{{name}}++`]]
-{{/each}}
-
-[.contract]
-[[{{anchor}}]]
-=== `++{{name}}++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v{{oz-version}}/{{__item_context.file.absolutePath}}[{github-icon},role=heading-link]
-
-[.hljs-theme-light.nopadding]
-```solidity
-import "@openzeppelin/{{__item_context.file.absolutePath}}";
-```
-
-{{{natspec.dev}}}
-
-{{#if modifiers}}
-[.contract-index]
-.Modifiers
---
-{{#each modifiers}}
-* {xref-{{anchor~}} }[`++{{name}}({{names params}})++`]
-{{/each}}
---
-{{/if}}
-
-{{#if has-functions}}
-[.contract-index]
-.Functions
---
-{{#each inherited-functions}}
-{{#unless @first}}
-[.contract-subindex-inherited]
-.{{contract.name}}
-{{/unless}}
-{{#each functions}}
-* {xref-{{anchor~}} }[`++{{name}}({{names params}})++`]
-{{/each}}
-
-{{/each}}
---
-{{/if}}
-
-{{#if has-events}}
-[.contract-index]
-.Events
---
-{{#each inheritance}}
-{{#unless @first}}
-[.contract-subindex-inherited]
-.{{name}}
-{{/unless}}
-{{#each events}}
-* {xref-{{anchor~}} }[`++{{name}}({{names params}})++`]
-{{/each}}
-
-{{/each}}
---
-{{/if}}
-
-{{#each modifiers}}
-[.contract-item]
-[[{{anchor}}]]
-==== `[.contract-item-name]#++{{name}}++#++({{typed-params params}})++` [.item-kind]#modifier#
-
-{{{natspec.dev}}}
-
-{{/each}}
-
-{{#each functions}}
-[.contract-item]
-[[{{anchor}}]]
-==== `[.contract-item-name]#++{{name}}++#++({{typed-params params}}){{#if returns}} → {{typed-params returns}}{{/if}}++` [.item-kind]#{{visibility}}#
-
-{{{natspec.dev}}}
-
-{{/each}}
-
-{{#each events}}
-[.contract-item]
-[[{{anchor}}]]
-==== `[.contract-item-name]#++{{name}}++#++({{typed-params params}})++` [.item-kind]#event#
-
-{{{natspec.dev}}}
-
-{{/each}}

package/lib/openzeppelin-contracts.git/docs/templates/helpers.js

@@ -1,46 +0,0 @@
-const { version } = require('../../package.json');
-
-module.exports['oz-version'] = () => version;
-
-module.exports['readme-path'] = (opts) => {
-  return 'contracts/' + opts.data.root.id.replace(/\.adoc$/, '') + '/README.adoc';
-};
-
-module.exports.names = (params) => params.map(p => p.name).join(', ');
-
-module.exports['typed-params'] = (params) => {
-  return params?.map(p => `${p.type}${p.indexed ? ' indexed' : ''}${p.name ? ' ' + p.name : ''}`).join(', ');
-};
-
-const slug = module.exports.slug = (str) => {
-  if (str === undefined) {
-    throw new Error('Missing argument');
-  }
-  return str.replace(/\W/g, '-');
-};
-
-const linksCache = new WeakMap();
-
-function getAllLinks (items) {
-  if (linksCache.has(items)) {
-    return linksCache.get(items);
-  }
-  const res = {};
-  linksCache.set(items, res);
-  for (const item of items) {
-    res[`xref-${item.anchor}`] = `xref:${item.__item_context.page}#${item.anchor}`;
-    res[slug(item.fullName)] = `pass:normal[xref:${item.__item_context.page}#${item.anchor}[\`${item.fullName}\`]]`;
-  }
-  return res;
-}
-
-module.exports['with-prelude'] = (opts) => {
-  const links = getAllLinks(opts.data.site.items);
-  const contents = opts.fn();
-  const neededLinks = contents
-    .match(/\{[-._a-z0-9]+\}/ig)
-    .map(m => m.replace(/^\{(.+)\}$/, '$1'))
-    .filter(k => k in links);
-  const prelude = neededLinks.map(k => `:${k}: ${links[k]}`).join('\n');
-  return prelude + '\n' + contents;
-};

package/lib/openzeppelin-contracts.git/docs/templates/page.hbs

@@ -1,4 +0,0 @@
-:github-icon: pass:[<svg class="icon"><use href="#github-icon"/></svg>]
-{{#with-prelude}}
-{{readme (readme-path)}}
-{{/with-prelude}}

package/lib/openzeppelin-contracts.git/docs/templates/properties.js

@@ -1,49 +0,0 @@
-const { isNodeType } = require('solidity-ast/utils');
-const { slug } = require('./helpers');
-
-module.exports.anchor = function anchor ({ item, contract }) {
-  let res = '';
-  if (contract) {
-    res += contract.name + '-';
-  }
-  res += item.name;
-  if ('parameters' in item) {
-    const signature = item.parameters.parameters.map(v => v.typeName.typeDescriptions.typeString).join(',');
-    res += slug('(' + signature + ')');
-  }
-  if (isNodeType('VariableDeclaration', item)) {
-    res += '-' + slug(item.typeName.typeDescriptions.typeString);
-  }
-  return res;
-};
-
-module.exports.inheritance = function ({ item, build }) {
-  if (!isNodeType('ContractDefinition', item)) {
-    throw new Error('used inherited-items on non-contract');
-  }
-
-  return item.linearizedBaseContracts
-    .map(id => build.deref('ContractDefinition', id))
-    .filter((c, i) => c.name !== 'Context' || i === 0);
-};
-
-module.exports['has-functions'] = function ({ item }) {
-  return item.inheritance.some(c => c.functions.length > 0);
-};
-
-module.exports['has-events'] = function ({ item }) {
-  return item.inheritance.some(c => c.events.length > 0);
-};
-
-module.exports['inherited-functions'] = function ({ item }) {
-  const { inheritance } = item;
-  const baseFunctions = new Set(
-    inheritance.flatMap(c => c.functions.flatMap(f => f.baseFunctions ?? [])),
-  );
-  return inheritance.map((contract, i) => ({
-    contract,
-    functions: contract.functions.filter(f =>
-      !baseFunctions.has(f.id) && (f.name !== 'constructor' || i === 0),
-    ),
-  }));
-};

package/lib/reality-eth-monorepo/packages/docs/Makefile

@@ -1,20 +0,0 @@
-# Minimal makefile for Sphinx documentation
-#
-
-# You can set these variables from the command line.
-SPHINXOPTS    =
-SPHINXBUILD   = python -msphinx
-SPHINXPROJ    = RealityCheck
-SOURCEDIR     = .
-BUILDDIR      = .
-
-# Put it first so that "make" without argument is like "make help".
-help:
-	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
-
-.PHONY: help Makefile
-
-# Catch-all target: route all unknown targets to Sphinx using the new
-# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
-%: Makefile
-	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)

package/lib/reality-eth-monorepo/packages/docs/arbitrators.rst

@@ -1,85 +0,0 @@
-Arbitrators
-=============
-
-.. toctree::
-   :maxdepth: 2
-   :caption: Contents:
-
-
-An arbitrator is responsible for providing a final answer to a question when there is a dispute, in exchange for a fee. If the arbitrator is untrustworthy, the system cannot be relied on to provide accurate answers.
-
-Any contract address can be set as the arbitrator. Our dapp currently lists only the Reality Keys trusted arbitrator contract, but others can be entered manually. We can add other contract addresses on request.
-
-Since arbitration is expensive, it will usually only be requested after parties have posted bonds, and the bonds have escalated to a level where the bond you stand to gain by paying for arbitration is higher than the fee. Accordingly, arbitrators should feel free to set fairly high fees that will adequately cover the cost of a thorough arbitration process.
-
-
-Arbitration Models
-------------------
-
-Trusted third-parties
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-The Reality.eth team have been providing a centralized arbitration service since 2013 beginning with the Reality Keys service. Use of this service is currently discouraged as decentralized alternatives are available.
-
-Kleros
-^^^^^^
-
-Kleros provide a decentralized court system that is integrated with reality.eth and has been used successfully for high-stakes settlement.
-
-Stakeholder voting
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-Where a consumer contract has their own token, they may choose to provide their own arbitrator contract allowing their own stakeholders to vote. Alternatively, it is possible to deploy a reality.eth contract using the token in question for bonds, then create questions without a registered arbitrator. That way the side able to martial the greatest amount of the token will prevail.
-
-
-Subjectivocracy
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-We are developing a system along the lines described in `Get the facts, hard-fork all the things`_. The `current design`_ envisages using a forkable Layer 2 ledger.
-
-.. _`Get the facts, hard-fork all the things`: https://decentralize.today/get-the-facts-hard-fork-all-the-things-3ea2233da0fd
-.. _`current design`: https://github.com/RealityETH/subjectivocracy
-
-
-
-
-Creating and using an arbitration contract
-------------------------------------------
-
-Arbitrator contracts should expose the following functions to users:
-
-* ``function getDisputeFee(bytes32 question_id) constant returns (uint256)``
-* ``function requestArbitration(bytes32 question_id)``
-
-When ``requestArbitration()`` is called with a sufficient fee, they should call the following against the Reality.eth contract:
-
-* ``notifyOfArbitrationRequest(bytes32 question_id, address requester)``
-
-When they produce an answer, they should settle the contract with:
-
-* ``submitAnswerByArbitrator(bytes32 question_id, bytes32 answer, address answerer)``
-
-If the result of arbitration is to affirm the answer given by the final answerer, the person who gave that answer should be supplied as ``answerer``. If the result of arbitration is to change the final answer, the ``answerer`` supplied should be the user who paid for arbitration. Since version 2.1, this behaviour can be enforced by a contract by instead using
-
-  ``assignWinnerAndSubmitAnswerByArbitrator(bytes32 question_id, bytes32 answer, address payee_if_wrong, bytes32 last_history_hash, bytes32 last_answer_or_commitment_id, address last_answerer)``
-
-The last 3 arguments can be extracted from event logs and supplied by the user sending the transaction, and are verified by the contract.
-
-.. note::
-   Sometimes the answer the arbitrator finalizes on will already have been given earlier, but with a lower bond. It may appear fairer to some for the arbitrator to set the ``answerer`` as the person who previously gave that answer, not the person who paid. However, for all we know the person who gave the correct answer could be a sock puppet belonging to the person who gave the final, wrong answer. Rewarding them would remove the disincentive to lie. For the system the incentive system to work correctly, it is essential that the arbitrator choose the person who paid them as the ``answerer``, unless the pre-existing final answer was correct.
-
-
-Getting information about the arbitrator
-----------------------------------------
-
-* ``function realitio()`` should provide the address of the Reality.eth contract to which the arbitrator responds.
-* ``function metadata()`` should provide a string of json-encoded metadata. It may contain the following properties
-
-  * ``tos``: A URI representing the location of a terms-of-service document for the arbitrator. Should be a URI, either a standard https:// URL or ipfs://
-  * ``foreignProxy: true``: This signals that the contract requires users to request arbitration on another chain, as with the Kleros cross-chain proxy. The contract will call additional methods against the contract to get the details of the foreign proxy.
-  * ``template_hashes``: [Not yet implemented] An array of hashes of templates supported by the arbitrator, if you want to limit usage of the arbitrator to specified templates. If you have a numerical ID for a template registered with Reality.eth, you can look up this hash by calling the Reality.eth ``template_hashes()`` function.
-
-See an `Arbitrator contract example`_ to show you how to set the metadata.
-
-.. _`Arbitrator contract example`: https://rinkeby.etherscan.io/address/0xF8175715a762514351dfe1aaaB83aF5F9DBcB5F5#readContract
-

package/lib/reality-eth-monorepo/packages/docs/audit.rst

@@ -1,12 +0,0 @@
-Audit
-=====
-
-.. toctree::
-   :maxdepth: 2
-   :caption: Contents:
-
-   audit_v2
-   audit_v2_ERC20
-   audit_v3
-
-