tornado-packages/ethers.js
1
0
Fork 1
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Consistent link names in docs.

Browse Source
This commit is contained in:
Richard Moore 2020-05-08 03:24:40 -04:00
parent 7f0374c5a5
commit 84d37fda83
No known key found for this signature in database
GPG Key ID: 665176BE8E9DC651
45 changed files with 2869 additions and 750 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs.wrm/.gitignore vendored Normal file
View File

@ -0,0 +1 @@
**.bak

77
docs.wrm/api/contract/contract-factory.wrm Normal file
View File

@ -0,0 +1,77 @@
_section: ContractFactory @<ContractFactory> @SRC<contracts:class.ContractFactory>
_subsection: Creating Instances @<ContractFactory--creating>
_property: new ethers.ContractFactory(interface, bydecode [ , signer ]) @SRC<contracts:constructor.ContractFactory>
_property: ContractFactory.fromSolidity(compilerOutput [ , signer ]) => [[ContractFactory]]
_property: contractFactory.connect(signer) => [[Contract]]
_subsection: Properties @<ContractFactory--properties>
_property: contractFactory.interface => [[Interface]]
_property: contractFactory.bytecode => string<[[DataHexString]]>
_property: contractFactory.signer => [[Signer]]
_subsection: Methods @<ContractFactory--methods>
_property: contractFactory.attach(address) => [[Contract]]
Return an instance of a [[Contract]] attched to //address//. This is the
same as using the [Contract constructor](contract--creating) with
//address// and this the the //interface// and //signerOrProvider// passed
in when creating the ContractFactory.
_property: contractFactory.getDeployTransaction(...args) => [[UnsignedTransaction]]
Returns the unsigned transaction which would deploy this Contract with //args// passed
to the Contract's constructor.
_property: contractFactory.deploy(...args) => Promise<[[Contract]]>
Uses the signer to deploy the Contract with //args// passed into tgee constructor and
retruns a Contract which is attached to the address where this contract **will** be
deployed once the transction is mined.
The transction can be found at ``contract.deployTransaction``, and no interactions
should be made until the transaction is mined.
_code: Deploying a Contract
// <hide>
const signer = ethers.LocalSigner();
const ContractFactory = ethers.ContractFactory;
// </hide>
// If your contract constructor requires parameters, the ABI
// must include the constructor
const abi = [
"constructor(address owner, uint256 initialValue)"
];
const factory = new ContractFactory(abi, bytecode, signer)
const contract = await factory.deploy("ricmoo.eth", 42);
// The address is available immediately, but the contract
// is NOT deployed yet
contract.address
//!
// The transaction that the signer sent to deploy
contract.deployTransaction
//!
// Wait until the transaction is mined
contract.deployTransaction.wait()
//!
// Now the contract is safe to ineract with
contract.value()
//!

99
docs.wrm/api/contract/contract.wrm
View File

@ -1,57 +1,64 @@
_section: Contract @<contract> @SRC<contracts:class.Contract>
_section: Contract @<Contract> @SRC<contracts:class.Contract>
_subsection: Properties
Explain contract here...
_property: contract.address => string<[[address]]>
This is the address (or ENS name) the contract was constructed with.
_subsection: Creating Instances @<contract--creating>
_property: contract.addressPromise => string<[[address]]>
This is a promise that will resolve to the address the **Contract**
object is attached to. If an [[address]] was provided to the constructor,
it will be equal to this; if an ENS name was provided, this will be the
resolved address.
_property: new ethers.Contract(address, abi, signerOrProvider) @src<contracts:constructor.Contract>
_property: contract.deployTransaction => [[provider-transactionresponse]]
If the **Contract** object is the result of a ContractFactory deployment,
this is the transaction which was used to deploy the contract.
_property: contract.interface => [[abi-interface]]
This is the ABI as an [[abi-interface]].
_property: contract.provider => [[provider]]
If a provider was provided to the constructor, this is that provider. If
a signer was provided that had a [[provider]], this is that provider.
_property: contract.signer => [[signer]]
If a signer was provided to the constructor, this is that signer.
_subsection: Methods
_property: contract.attach(addressOrName) => [[contract]] @<contract-attach> @SRC<contracts:Contract.attach>
_property: contract.attach(addressOrName) => [[Contract]] @<contract-attach> @SRC<contracts:Contract.attach>
Returns a new instance of the **Contract** attached to a new
address. This is useful if there are multiple similar or identical
copies of a Contract on the network and you wish to interact with
each of them.
_property: contract.connect(providerOrSigner) => [[contract]] @<contract-connect> @SRC<contracts:Contract.connect>
_property: contract.connect(providerOrSigner) => [[Contract]] @<contract-connect> @SRC<contracts:Contract.connect>
Returns a new instance of the Contract, but connected to
//providerOrSigner//.
By passing in a [[provider]], this will return a downgraded
By passing in a [[Provider]], this will return a downgraded
**Contract** which only has read-only access (i.e. constant calls).
By passing in a [[signer]]. the will return a **Contract** which
By passing in a [[Signer]]. the will return a **Contract** which
will act on behalf of that signer.
_property: contract.deployed() => Promise<[[contract]]> @<contract-deployed> @SRC<contracts>
_subsection: Properties @<contrct--properties>
_property: contract.address => string<[[address]]>
This is the address (or ENS name) the contract was constructed with.
_property: contract.resolvedAddress => string<[[address]]>
This is a promise that will resolve to the address the **Contract**
object is attached to. If an [[address]] was provided to the constructor,
it will be equal to this; if an ENS name was provided, this will be the
resolved address.
_property: contract.deployTransaction => [[providers-TransactionResponse]]
If the **Contract** object is the result of a ContractFactory deployment,
this is the transaction which was used to deploy the contract.
_property: contract.interface => [[Interface]]
This is the ABI as an [[Interface]].
_property: contract.provider => [[Provider]]
If a provider was provided to the constructor, this is that provider. If
a signer was provided that had a [[Provider]], this is that provider.
_property: contract.signer => [[Signer]]
If a signer was provided to the constructor, this is that signer.
_subsection: Methods
_property: contract.deployed() => Promise<[[Contract]]> @<contract-deployed> @SRC<contracts>
_property: Contract.isIndexed(value) => boolean @<contract-isIndexed> @SRC<contracts>
_subsection: Events
_property: contract.queryFilter(event [ , fromBlockOrBlockHash [ , toBlock ]) => Promise<Array<Event>> @<contract-queryfilter> @SRC<contracts>
_property: contract.queryFilter(event [ , fromBlockOrBlockHash [ , toBlock ]) => Promise<Array<Event>> @<contract-queryFilter> @SRC<contracts>
Return Events that match the //event//.
_property: contract.listenerCount([ event ]) => number @<contract-listenerCount> @SRC<contracts:Contract.listenerCount>
@ -76,7 +83,7 @@ Unsubscribe all listeners for //event//. If no event is provided,
all events are unsubscribed.
_subsection: Meta-Class @<contract-metaclass>
_subsection: Meta-Class @<contract--metaclass>
A Meta-Class is a Class which has any of its properties determined
at run-time. The **Contract** object uses a Contract's ABI to
@ -85,7 +92,7 @@ describe the generic ways to interact with the properties added
at run-time during the **Contract** constructor.
_heading: Read-Only Methods (constant) @<contract-readonly>
_heading: Read-Only Methods (constant) @<contract--readonly>
A constant method is read-only and evaluates a small amount of EVM
code against the current blockchain state and can be computed by
@ -93,7 +100,7 @@ asking a single node, which can return a result. It is therefore
free and does not require any ether, but **cannot make changes** to
the blockchain state..
_property: contract.METHOD_NAME(...args [ overrides ]) => Promise<any> @<contract-call>
_property: contract.METHOD_NAME(...args [ overrides ]) => Promise<any> @<contract-functionsCall>
The type of the result depends on the ABI.
For values that have a simple meaning in JavaScript, the types are fairly
@ -102,12 +109,12 @@ and booleans.
For numbers, if the **type** is in the JavaSsript safe range (i.e. less
than 53 bits, such as an ``int24`` or ``uint48``) a normal JavaScript
number is used. Otherwise a [[bignumber]] is returned.
number is used. Otherwise a [[BigNumber]] is returned.
For bytes (both fixed length and dynamic), a [[datahexstring]] is returned.
For bytes (both fixed length and dynamic), a [[DataHexString]] is returned.
_heading: Write Methods (non-constant) @<contract-write>
_heading: Write Methods (non-constant) @<contract--write>
A non-constant method requires a transaction to be signed and requires
payment in the form of a fee to be paid to a miner. This transaction
@ -119,23 +126,23 @@ It cannot return a result. If a result is required, it should be logged
using a Solidity event (or EVM log), which can then be queried from the
transaction receipt.
_property: contract.METHOD_NAME(...args [ , overrides ]) => Promise<[[provider-transactionresponse]]> @<contract-send>
Returns a [[provider-transactionresponse]] for the transaction after
_property: contract.METHOD_NAME(...args [ , overrides ]) => Promise<[[providers-TransactionResponse]]> @<contract-functionsSend>
Returns a [[providers-TransactionResponse]] for the transaction after
it is sent to the network. This requires the **Contract** has a
signer.
_heading: Write Methods Analysis @<contract-write-check>
_heading: Write Methods Analysis @<contract--check>
There are secveral options to analyze properties and results of a
write method without actually executing it.
_property: contract.estimateGas.METHOD_NAME(...args [ , overrides ]) => Promise<[[bignumber]]> @<contract-estimateGas>
_property: contract.estimateGas.METHOD_NAME(...args [ , overrides ]) => Promise<[[BigNumber]]> @<contract-estimateGas>
Returns the estimate units of gas that would be required to
execute the //METHOD_NAME// with //args// and //overrides//.
_property: contract.populateTransaction.METHOD_NAME(...args [ , overrides ]) => Promise<[UnsignedTx](types-unsignedtransaction)> @<contract-populateTransaction>
Returns an [[types-unsignedtransaction]] which represents the transaction
_property: contract.populateTransaction.METHOD_NAME(...args [ , overrides ]) => Promise<[UnsignedTx](UnsignedTransaction)> @<contract-populateTransaction>
Returns an [[UnsignedTransaction]] which represents the transaction
that would need to be signed and submitted to the network to execute
//METHOD_NAME// with //args// and //overrides//.
@ -147,9 +154,9 @@ return the result.
This does not actually chagne any state, but is free. This in some cases
can be used to determine if a transaction will fail or succeed.
This otherwise functions the same as a [Read-Only Method](contract-readonly).
This otherwise functions the same as a [Read-Only Method](contract--readonly).
_heading: Event Filters @<contract-filter>
_heading: Event Filters @<contract-filters>
An event filter is made up of topics, which are values logged in a
[[link-wiki-bloomfilter]], allowing efficient searching for entries
which match a filter.

42
docs.wrm/api/contract/example.wrm
View File

@ -41,7 +41,7 @@ const erc20 = new ethers.Contract(address, abi, provider);
const erc20_rw = new ethers.Contract(address, abi, signer)
_heading: ERC20Contract @INHERIT<[[contract]]>
_heading: ERC20Contract @INHERIT<[[Contract]]>
_property: new ethers.Contract(address, abi, providerOrSigner)
See the above code example for creating an Instance which will
@ -50,48 +50,48 @@ add the additional properties defined in //abi// to a **Contract**
connected to //address// using the //providerOrSigner//.
_subsection: Properties @NOTE<(inheritted from [[contract]])>
_subsection: Properties @NOTE<(inheritted from [[Contract]])>
_property: erc20.address => string<[[address]]>
This is the address (or ENS name) the contract was constructed with.
_property: erc20.addressPromise => string<[[address]]>
_property: erc20.resolvedAddress => string<[[address]]>
This is a promise that will resolve to the address the **Contract**
object is attached to. If an [[address]] was provided to the constructor,
it will be equal to this; if an ENS name was provided, this will be the
resolved address.
_property: erc20.deployTransaction => [[provider-transactionresponse]]
_property: erc20.deployTransaction => [[providers-TransactionResponse]]
If the **Contract** object is the result of a ContractFactory deployment,
this is the transaction which was used to deploy the contract.
_property: erc20.interface => [[abi-interface]]
This is the ABI as an [[abi-interface]].
_property: erc20.interface => [[Interface]]
This is the ABI as an [[Interface]].
_property: erc20.provider => [[provider]]
_property: erc20.provider => [[Provider]]
If a provider was provided to the constructor, this is that provider. If
a signer was provided that had a [[provider]], this is that provider.
a signer was provided that had a [[Provider]], this is that provider.
_property: erc20.signer => [[signer]]
_property: erc20.signer => [[Signer]]
If a signer was provided to the constructor, this is that signer.
_subsection: Methods @NOTE<(inheritted from [[contract]])>
_subsection: Methods @NOTE<(inheritted from [[Contract]])>
_property: erc20.attach(addressOrName) => [[contract]]
_property: erc20.attach(addressOrName) => [[Contract]]
Returns a new instance of the **Contract** attached to a new
address. This is useful if there are multiple similar or identical
copies of a Contract on the network and you wish to interact with
each of them.
_property: erc20.connect(providerOrSigner) => [[contract]]
_property: erc20.connect(providerOrSigner) => [[Contract]]
Returns a new instance of the Contract, but connected to
//providerOrSigner//.
By passing in a [[provider]], this will return a downgraded
By passing in a [[Provider]], this will return a downgraded
**Contract** which only has read-only access (i.e. constant calls).
By passing in a [[signer]]. the will return a **Contract** which
By passing in a [[Signer]]. the will return a **Contract** which
will act on behalf of that signer.
_property: erc20.deployed() => Promise<Contract>
@ -99,7 +99,7 @@ _property: erc20.deployed() => Promise<Contract>
_property: Contract.isIndexed(value) => boolean
_subsection: Events @NOTE<(inheritted from [[contract]])> @<erc20-events>
_subsection: Events @NOTE<(inheritted from [[Contract]])> @<erc20-events>
_property: erc20.queryFilter(event [ , fromBlockOrBlockHash [ , toBlock ]) => Promise<Array<Event>> @<erc20-queryfilter>
Return Events that match the //event//.
@ -133,16 +133,16 @@ on the ABI which was passed into the **Contract**.
_property: erc20.decimals([ overrides ]) => Promise<number>
Returns the number of decimal places used by this ERC-20 token. This can be
used with [parseUnits](utils-parseunits) when taking input from the user or
used with [parseUnits](utils-parseUnits) when taking input from the user or
[formatUnits](utils-formatunits] when displaying the token amounts in the UI.
_property: erc20.getBalance(owner [, overrides ]) => Promise<[[bignumber]]>
_property: erc20.getBalance(owner [, overrides ]) => Promise<[[BigNumber]]>
Returns the balance of //owner// for this ERC-20 token.
_property: erc20.symbol([ overrides ]) => Promise<string>
Returns the symbol of the token.
_property: erc20_rw.transfer(target, amount [, overrides ]) => Promise<[[provider-transactionresponse]]>
_property: erc20_rw.transfer(target, amount [, overrides ]) => Promise<[[providers-TransactionResponse]]>
Transfers //amount// tokens to //target// from the current signer.
The return value (a boolean) is inaccessible during a write operation
using a transaction. Other techniques (such as events) are required
@ -155,12 +155,12 @@ the current signer, without actually signing or sending a transaction.
This can be used to preflight check that a transaction will be successful.
_property: erc20.estimate.transfer(target, amount [, overrides ]) => Promise<[[bignumber]]>
_property: erc20.estimateGas.transfer(target, amount [, overrides ]) => Promise<[[BigNumber]]>
Returns an estimate for how many units of gas would be required
to transfer //amount// tokens to //target//.
_property: erc20.populateTransaction.transfer(target, amount [, overrides ]) => Promise<[UnsignedTx](types-unsignedtransaction)>
Returns an [[types-unsignedtransaction]] which could be signed and submitted
_property: erc20.populateTransaction.transfer(target, amount [, overrides ]) => Promise<[UnsignedTx](UnsignedTransaction)>
Returns an [[UnsignedTransaction]] which could be signed and submitted
to the network to transaction //amount// tokens to //target//.

8
docs.wrm/api/contract/index.wrm
View File

@ -1,8 +1,14 @@
_section: Contract Interaction @<contracts>
Explain what contracts are...
A **Contract** object is an abstraction of a contract (EVM bytecode)
deployed on the Ethereum network. It allows for a simple way to
serialize calls and transaxtions to an on-chain contract and
deserialize their results and emitted logs.
A **ContractFactory** is an abstraction a contract's //bytecode//
and facilitates deploying a contract.
_toc:
contract
contract-factory
example

10
docs.wrm/api/experimental.wrm
View File

@ -5,7 +5,7 @@ to be included in the base library. The API should not be considered
stable and does not follow [[link-semver]] versioning, so applications
requiring it should specify the //exact version// needed.
_subsection: BrainWallet @<experimental-brainwallet> @INHERIT<[[wallet]]>
_subsection: BrainWallet @<experimental-brainwallet> @INHERIT<[[Wallet]]>
Ethers removed support for BrainWallets in v4, since they are unsafe and
many can be easily guessed, allowing attackers to steal the funds. This
@ -22,12 +22,12 @@ Generate a brain wallet which is compatibile with the ethers v3 and earlier.
_subsection: EIP1193Bridge @<experimental-eip1193bridge> @INHERIT<[[link-npm-events]]>
The **EIP1193Bridge** allows a normal Ethers [[signer]] and [[provider]] to be
The **EIP1193Bridge** allows a normal Ethers [[Signer]] and [[Provider]] to be
exposed in as a standard [EIP-1193 Provider](link-eip-1193), which may be useful
when interacting with other libraries.
_subsection: NonceManager @<experimental-noncemanager> @INHERIT<[[signer]]>
_subsection: NonceManager @<experimental-noncemanager> @INHERIT<[[Signer]]>
The **NonceManager** is designed to manage the nonce for a Signer,
automatically increasing it as it sends transactions.
@ -46,10 +46,10 @@ a transaction is dependent on another transaction being mined first.
_property: new NonceManager(signer)
Create a new NonceManager.
_property: nonceManager.signer => [[signer]]
_property: nonceManager.signer => [[Signer]]
The signer whose nonce is being managed.
_property: nonceManager.provider => [[provider]]
_property: nonceManager.provider => [[Provider]]
The provider associated with the signer.
_property: nonceManager.setTransactionCount(count) => void

4
docs.wrm/api/other/assembly/api.wrm
View File

@ -8,7 +8,7 @@ The assembler utilities allow parsing and assembling an
_property: asm.parse(code) => [[asm-node]] @<asm-parse> @SRC<asm/assembler>
Parse an ethers-format assembly file and return the [[asm-ast]].
_property: asm.assemble(node) => string<[[datahexstring]]> @SRC<asm/assembler:function.assemble>
_property: asm.assemble(node) => string<[[DataHexString]]> @SRC<asm/assembler:function.assemble>
Performs assembly of the [[asm-ast]] //node// and return the
resulting bytecode representation.
@ -45,7 +45,7 @@ The opcode for this Operation.
_property: operation.offset => number
The offset into the bytecode for this Operation.
_property: operation.pushValue => string<[[datahexstring]]>
_property: operation.pushValue => string<[[DataHexString]]>
If the opcode is a ``PUSH``, this is the value of that push

2
docs.wrm/api/other/assembly/ast.wrm
View File

@ -44,7 +44,7 @@ A **ValueNode** is a node which may manipulate the stack.
_heading: LiteralNode @<asm-literalnode> @INHERIT<[[asm-valuenode]]> @SRC<asm:class.LiteralNode>
_property: literalNode.value => string
The literal value of this node, which may be a [[datahexstring]] or
The literal value of this node, which may be a [[DataHexString]] or
string of a decimal number.
_property: literalNode.verbatim => boolean

2
docs.wrm/api/other/assembly/dialect.wrm
View File

@ -42,7 +42,7 @@ _subsection: Literals @<asm-dialect-literal>
A **Literal** puts data on the stack when executed using a ``PUSH``
operation.
A **Literal** can be provided using a [[datahexstring]] or a decimal
A **Literal** can be provided using a [[DataHexString]] or a decimal
byte value.
@TODO: exmples

9
docs.wrm/api/other/hardware/index.wrm
View File

@ -1,11 +1,16 @@
_section: Hardware Wallets
_subsection: LedgerSigner @<hw-ledger> @INHERIT<[[signer]]> @SRC<hardware-wallets:class.LedgerSigner>
_subsection: LedgerSigner @<hw-ledger> @INHERIT<[[Signer]]> @SRC<hardware-wallets:class.LedgerSigner>
The [Ledger Hardware Wallets](link-ledger) are a fairly
popular brand.
TODO: importing
_code: Importing in ES6 or TypeScript @lang<script>
import { LedgerSigner } from "@ethersproject/hardware-wallets";
_heading: API

169
docs.wrm/api/providers/api-providers.wrm
View File

@ -1,4 +1,4 @@
_section: API Providers
_section: API Providers @<api-providers>
There are many services which offer a web API for accessing
the Ethereum Blockchain. These Providers allow connecting
@ -8,17 +8,34 @@ to run your own instance or cluster of Ethereum nodes.
However, this reliance on third-party services can reduce
resiliance, security and increase the amount of required trust.
To mitigate these issues, it is recommended you use a
[Default Provider](get-default-provider).
[Default Provider](providers-getDefaultProvider).
_subsection: EtherscanProvider @INHERIT<[[provider]]>
_subsection: EtherscanProvider @<EtherscanProvider> @inherit<[[Provider]]> @src<providers:class.EtherscanProvider>
The **EtherscanProvider** is backed by a combination of the various
[Etherscan APIs](link-etherscan-api).
_property: provider.getHistory(address) => Array<History>
_property: new ethers.providers.EtherscanProvider([ network = "homestead", [ apiKey ] ])
Create a new **EtherscanProvider** connected to //network// with the
optional //apiKey//.
The //network// may be specified as **string** for a common
network name, a **number** for a common chain ID or a
[Network Object]provider-(network).
If no //apiKey// is provided, a shared API key will be used,
which may result in reduced performance and throttled requests.
It is highly recommended for production, you register with
[Etherscan](link-etherscan) for your own API key.
_note: Note: Default API keys
If no //apiKey// is provided, a shared API key will be used,
which may result in reduced performance and throttled requests.
It is highly recommended for production, you register with
[Etherscan](link-etherscan) for your own API key.
@TODO... Explain
_definition: **Supported Networks**
@ -28,24 +45,63 @@ _definition: **Supported Networks**
- G&ouml;rli (clique testnet)
- Kovan (proof-of-authority testnet)
_code: Etherscan Examples @lang<javascript>
_subsection: InfuraProvider @INHERIT<[[provider-urljsonrpc]]>
// <hide>
const EtherscanProvider = ethers.providers.EtherscanProvider;
const apiKey = "...";
// </hide>
// Connect to mainnet (homestead)
provider = new EtherscanProvider();
// Connect to rinkeby testnet (these are equivalent)
provider = new EtherscanProvider("rinkeby");
provider = new EtherscanProvider(4);
const network = ethers.providers.getNetwork("rinkeby");
// <hide>
delete network._defaultProvider;
network
// </hide>
//!
provider = new EtherscanProvider(network);
// Connect to mainnet (homestead) with an API key
provider = new EtherscanProvider(null, apiKey);
provider = new EtherscanProvider("homestead", apiKey);
_property: provider.getHistory(address) => Array<History> @src<providers>
@TODO... Explain
_subsection: InfuraProvider @INHERIT<[[UrlJsonRpcProvider]]> @src<providers:class.InfuraProvider>
The **InfuraProvider** is backed by the popular [INFURA](link-infura)
Ethereum service.
_definition: **Supported Networks**
_property: new ethers.providers.InfuraProvider([ network = "homestead", [ apiKey ] ])
Create a new **InfuraProvider** connected to //network// with
the optional //apiKey//.
- Homestead (Mainnet)
- Ropsten (proof-of-work testnet)
- Rinkeby (proof-of-authority testnet)
- G&ouml;rli (clique testnet)
- Kovan (proof-of-authority testnet)
The //network// may be specified as **string** for a common
network name, a **number** for a common chain ID or a
[Network Object]provider-(network).
The //apiKey// can be a **string** Project ID or an **object**
with the properties ``projectId`` and ``projectSecret`` to
specify a [Project Secret](link-infura-secret) which can be used
on non-public sources (like on a server) to further secure your
API access and quotas.
_subsection: AlchemyProvider @INHERIT<[[provider-urljsonrpc]]>
_note: Note: Default API keys
If no //apiKey// is provided, a shared API key will be used,
which may result in reduced performance and throttled requests.
The **AlchemtProvider** is backed by [Alchemy](link-alchemy).
It is highly recommended for production, you register with
[INFURA](link-infura) for your own API key.
_definition: **Supported Networks**
@ -55,11 +111,94 @@ _definition: **Supported Networks**
- G&ouml;rli (clique testnet)
- Kovan (proof-of-authority testnet)
_code: INFURA Examples @lang<javascript>
_subsection: CloudflareProvider @INHERIT<[[provider-urljsonrpc]]>
// <hide>
const InfuraProvider = ethers.providers.InfuraProvider;
const projectId = "...";
const projectSecret = "...";
// </hide>
// Connect to mainnet (homestead)
provider = new InfuraProvider();
// Connect to the ropsten testnet
// (see EtherscanProvider above for other network examples)
provider = new InfuraProvider("ropsten");
// Connect to mainnet with a Project ID (these are equivalent)
provider = new InfuraProvider(null, projectId);
provider = new InfuraProvider("homestead", projectId);
// Connect to mainnet with a Project ID and Project Secret
provider = new InfuraProvider("homestead", {
projectId: projectId,
projectSecret: projectSecret
});
_subsection: AlchemyProvider @inherit<[[UrlJsonRpcProvider]]> @src<providers:class.AlchemyProvider>
The **AlchemyProvider** is backed by [Alchemy](link-alchemy).
_property: new ethers.providers.AlchemyProvider([ network = "homestead", [ apiKey ] ])
Create a new **AlchemyProvider** connected to //network// with
the optional //apiKey//.
The //network// may be specified as **string** for a common
network name, a **number** for a common chain ID or a
[Network Object](providers-Network).
_note: Note: Default API keys
If no //apiKey// is provided, a shared API key will be used,
which may result in reduced performance and throttled requests.
It is highly recommended for production, you register with
[Alchemy](link-alchemy) for your own API key.
_definition: **Supported Networks**
- Homestead (Mainnet)
- Ropsten (proof-of-work testnet)
- Rinkeby (proof-of-authority testnet)
- G&ouml;rli (clique testnet)
- Kovan (proof-of-authority testnet)
_code: Alchemy Examples @lang<javascript>
// <hide>
const AlchemyProvider = ethers.providers.AlchemyProvider;
const apiKey = "...";
// </hide>
// Connect to mainnet (homestead)
provider = new AlchemyProvider();
// Connect to the ropsten testnet
// (see EtherscanProvider above for other network examples)
provider = new AlchemyProvider("ropsten");
// Connect to mainnet with an API key (these are equivalent)
provider = new AlchemyProvider(null, apiKey);
provider = new AlchemyProvider("homestead", apiKey);
_subsection: CloudflareProvider @inherit<[[UrlJsonRpcProvider]]> @src<providers:class.CloudflareProvider>
The CloudflareProvider is backed by the [Cloudflare Ethereum Gateway](link-cloudflare).
_property: new ethers.providers.CloudflareProvider()
Create a new **CloudflareProvider** connected to mainnet (i.e. "homestead").
_definition: **Supported Networks**
- Homestead (Mainnet)
_code: Cloudflare Examples @lang<javascript>
// <hide>
const CloudflareProvider = ethers.providers.CloudflareProvider;
// </hide>
// Connect to mainnet (homestead)
provider = new CloudflareProvider();

42
docs.wrm/api/providers/index.wrm
View File

@ -9,16 +9,16 @@ cover the vast majority of use-cases, but also includes the
necessary functions and classes for sub-classing if a more
custom configuration is necessary.
Most users should be able to simply use the [[get-default-provider]].
Most users should be able to simply use the [[providers-getDefaultProvider]].
_subsection: Default Provider @<get-default-provider>
_subsection: Default Provider @<providers-getDefaultProvider>
The default provider is the safest, easiest way to begin
developing on //Ethereum//, and it is also robust enough
for use in production.
It creates a [[provider-fallback]] connected to as many backend
It creates a [[FallbackProvider]] connected to as many backend
services as possible. When a request is made, it is sent to
multiple backends simulatenously. As responses from each backend
are returned, they are checked that they agree. Once a quorum
@ -29,11 +29,45 @@ This ensures that if a backend has become out-of-sync, or if it
has been compromised that its responses are dropped in favor of
responses that match the majority.
_property: ethers.getDefaultProvider([ network ]) => [[provider]]
_property: ethers.getDefaultProvider([ network, [ options ] ]) => [[Provider]]
Returns a new Provider, backed by multiple services, connected
to //network//. Is no //network// is provided, **homestead**
(i.e. mainnet) is used.
The //options// is an object, with the following properties:
_table: Option Properties
$Alchemy: [[link-alchemy]] API Token
$Etherscan: [[link-etherscan]] API Token
$Infura: [[link-infura]] Project ID or ProjectID and Project Secret
$Quroum: The number of backends that must agree
//(default: 2 for mainnet, 1 for testnets)//
| **Property** | **Description** |
| alchemy | $Alchemt |
| etherscan | $Etherscan |
| infura | $Infura |
| quorum | $Quorum |
_note: Note: API Keys
It is highly recommended for production services that to acquire
and specify an API Key for each sercice.
The deafult API Keys used by ethers are shared across all users,
so services may throttle all services that are using the default
API Keys during periods of load without realizing it.
Many services also have monitoring and usage metrics, which are
only available if an API Key is specifie. This allows tracking
how many requests are being sent and which methods are being
used the most.
Some services also provide additional paid features, whichare only
available when specifying an API Key.
_subsection: Provider Documentation
_toc:

71
docs.wrm/api/providers/jsonrpc-provider.wrm
View File

@ -1,73 +1,92 @@
_section: JsonRpcProvider @<provider-jsonrpc> @INHERIT<[[provider]]>
_section: JsonRpcProvider @<JsonRpcProvider> @INHERIT<[[Provider]]> @SRC<providers:class.JsonRpcProvider>
The [JSON-RPC API](link-jsonrpc) is a
very popular method for interacting with Ethereum and is available in all
major Ethereum node implementations (e.g. [Geth](link-geth)
and [Parity](link-parity)) as well as many third-party web
services (e.g. [INFURA](link-infura))
The [JSON-RPC API](link-jsonrpc) is a very popular method for interacting
with Ethereum and is available in all major Ethereum node implementations
(e.g. [[link-geth]] and [[link-parity]]) as well as many
third-party web services (e.g. [[link-infura]])
_property: new ethers.providers.JsonRpcProvider([ url [ , aNetworkish ] ])
_property: new ethers.providers.JsonRpcProvider([ url [ , aNetworkish ] ]) @SRC<providers:constructor.JsonRpcProvider>
Connect to a JSON-RPC API located at //url// using the //aNetworkish// network.
If //url// is not specified, the default (i.e. ``http:/\/localhost:8545``) is used
and if no network is specified, it will be determined automatically by
querying the node.
_note: Note: Connecting to a Local Node
Each node implementation is slightly different and may require specific command-line
flags or changes in their Settings UI to enable JSON-RPC, unlock accounrs
or expose specific APIs. Please consult theit documentation.
Each node implementation is slightly different and may require specific
command-line flags, configuration or settings in their UI to enable
JSON-RPC, unlock accounrs or expose specific APIs. Please consult
their documentation.
_property: jsonRpcProvider.getSigner([ addressOrIndex ]) => [[signer-jsonrpc]] @<provider-jsonrpc-getsigner> @SRC<providers/json-rpc-provider>
Returns a [[signer-jsonrpc]] which is managed by this Ethereum node, at
_property: jsonRpcProvider.getSigner([ addressOrIndex ]) => [[JsonRpcSigner]] @<JsonRpcProvider-getSigner> @SRC<providers/json-rpc-provider>
Returns a [[JsonRpcSigner]] which is managed by this Ethereum node, at
//addressOrIndex//. If no //addressOrIndex// is provided, the first
account (account #0) is used.
_property: jsonRpcProvider.getUncheckedSigner([ addressOrIndex ]) => [[provider-jsonrpc-uncheckedsigner]] @<provider-jsonrpc-getuncheckedsigner> @SRC<providers/json-rpc-provider>
_property: jsonRpcProvider.getUncheckedSigner([ addressOrIndex ]) => [[UncheckedJsonRpcSigner]] @<JsonRpcProvider-getUncheckedSigner> @SRC<providers/json-rpc-provider>
_property: jsonRpcProvider.listAccounts() => Array<string> @<provider-jsonrpc-listaccounts> @SRC<providers/json-rpc-provider>
_property: jsonRpcProvider.listAccounts() => Array<string> @<JsonRpcProvider-listAccounts> @SRC<providers/json-rpc-provider>
Returns a list of all account addresses managed by this provider.
_property: jsonRpcProvider.send(method, params) => Promise<any> @<provider-jsonrpc-send> @SRC<providers/json-rpc-provider>
_property: jsonRpcProvider.send(method, params) => Promise<any> @<JsonRpcProvider-send> @SRC<providers/json-rpc-provider>
Allows sending raw messages to the provider.
This can be used for backend-specific calls, such as for debugging or
specific account management.
_subsection: JsonRpcSigner @<signer-jsonrpc> @INHERIT<[[signer]]>
_subsection: JsonRpcSigner @<JsonRpcSigner> @INHERIT<[[Signer]]> @SRC<providers:class.JsonRpcSigner>
A **JsonRpcSigner** is a simple Signer which is backed by a connected
[[provider-jsonrpc]].
[[JsonRpcProvider]].
_property: signer.provider => [[provider-jsonrpc]]
_property: signer.provider => [[JsonRpcProvider]]
The provider this signer was established from.
_property: signer.connectUnchecked() => [[provider-jsonrpc-uncheckedsigner]]
_property: signer.connectUnchecked() => [[UncheckedJsonRpcSigner]] @<JsonRpcSigner-connectUnchecked> @SRC<providers>
Returns a new Signer object which does not perform addtional checks when
sending a transaction. See [[provider-jsonrpc-uncheckedsigner]] for more details.
sending a transaction. See [getUncheckedSigner](JsonRpcProvider-getUncheckedSigner) for more details.
_property: signer.sendUncheckedTransaction(transaction) => Promise<string<[[datahexstring]]<32>>>
_property: signer.sendUncheckedTransaction(transaction) => Promise<string<[[DataHexString]]\<32>\>> @<JsonRpcSigner-sendUncheckedTransaction> @SRC<providers>
Sends the //transaction// and returns a Promise which resolves to the
opacque transaction hash.
_property: signer.unlock(password) => Promise<boolean>
_property: signer.unlock(password) => Promise<boolean> @<JsonRpcSigner-unlock> @SRC<providers>
Request the node unlock the account (if locked) using //password//.
_subsection: JsonRpcUncheckedSigner @<provider-jsonrpc-uncheckedsigner> @INHERIT<[[signer]]>
_subsection: JsonRpcUncheckedSigner @<UncheckedJsonRpcSigner> @INHERIT<[[Signer]]> @SRC<providers:class.UncheckedJsonRpcSigner>
The JSON-RPC API only provides a transaction hash as the response when a
transaction is sent, but the ethers Provider requires populating all details
of a transaction before returning it. For example, the gas price and gas limit
may be adjusted by the node or the nonce automatically included, in which case
the opaque transaction hash has discarded this.
To remedy this, the [[signer-jsonrpc]] immeidately queries the provider for
the details using the returned transaction hash to populate the [[provider-transactionresponse]]
To remedy this, the [[JsonRpcSigner]] immeidately queries the provider for
the details using the returned transaction hash to populate the [[providers-TransactionResponse]]
object.
Some backends do not respond immediately and instead defer releasing the
details of a transaction it was responsible for signing until it is mined.
The **UncheckedSigner** does not populate any additional information and will
immediately return the result as a mock [[provider-transactionresponse]]-like
immediately return the result as a mock [[providers-TransactionResponse]]-like
object, with most of the properties set to null, but allows access to the
transaction hash quickly, if that is all that is required.
_subsection: Node-Specific Methods @<JsonRpcProvider--other>
Many methods are less common or specific to certain Ethereum Node implementations
(e.g. [Parity](link-parity) vs [Geth](link-geth). These include account and admin management,
debugging, deeper block and transaction exploration and other services (such as
Swarm and Whisper).
The [jsonRpcProvider.send](JsonRpcProvider-send) method can be used to access these.
- [All JSON-RPC methods](link-json-rpc) (including the less common methods) which most
Ethereum Nodes support.
- [Parity's Trace Module](link-parity-trace) can be used to trace and debug EVM
execcution of a transaction (requires custom configuration)
- [Geth's Debug Module](link-geth-debug) can be used to debug transactions and
internal cache state, etc.
- [Additional Geth Methods](link-geth-rpc)
- [Additional Parity Methods](link-parity-rpc)

32
docs.wrm/api/providers/other.wrm
View File

@ -2,12 +2,12 @@ _section: Other Providers
Others...
_subsection: FallbackProvider @<provider-fallback> @INHERIT<[[provider]]> @SRC<providers/fallback-provider:class.FallbackProvider>
_subsection: FallbackProvider @<FallbackProvider> @INHERIT<[[Provider]]> @SRC<providers/fallback-provider:class.FallbackProvider>
The **FallbackProvider** is the most advanced [[provider]] available in
The **FallbackProvider** is the most advanced [[Provider]] available in
ethers.
It uses a quorum and connects to multiple [Providers](provider) as backends,
It uses a quorum and connects to multiple [Providers](Provider) as backends,
each configured with a //priority// and a //weight// .
When a request is made, the request is dispatched to multiple backends, randomly
@ -23,10 +23,10 @@ Creates a new instance of a FallbackProvider connected to //providers//. If
quorum is not specified, half of the total sum of the provider weights is
used.
The //providers// can be either an array of [[provider]] or [[provider-fallback-config]].
If a [[provider]] is provided, the defaults are a priority of 1 and a weight of 1.
The //providers// can be either an array of [[Provider]] or [[FallbackProviderConfig]].
If a [[Provider]] is provided, the defaults are a priority of 1 and a weight of 1.
_property: provider.providerConfigs => Array<[[provider-fallback-config]]>
_property: provider.providerConfigs => Array<[[FallbackProviderConfig]]>
The list of Provider Configurations that describe the backends.
_property: provider.quorum => number
@ -34,9 +34,9 @@ The quorum the backend responses must agree upon before a result will be
resolved. By default this is //half the sum of the weights//.
_heading: FallbackProviderConfig @<provider-fallback-config>
_heading: FallbackProviderConfig @<FallbackProviderConfig>
_property: fallbackProviderConfig.provider => [[provider]]
_property: fallbackProviderConfig.provider => [[Provider]]
The provider for this configuration.
_property: fallbackProviderConfig.priority => number
@ -45,7 +45,7 @@ priorities. If multiple providers share the same prioirty, they are choosen
at random.
_property: fallbackProviderConfig.stallTimeout => number
The timeout (in ms) after which another [[provider]] will be attempted. This
The timeout (in ms) after which another [[Provider]] will be attempted. This
does not affect the current Provider; if it returns a result it is counted
as part of the quorum.
@ -54,10 +54,10 @@ time of requests.
_property: fallbackProviderConfig.weight => number
The weight a response from this provider provides. This can be used if a given
[[provider]] is more trusted, for example.
[[Provider]] is more trusted, for example.
_subsection: IpcProvider @<provider-ipc> @INHERIT<[[provider-jsonrpc]]> @SRC<providers:class.IpcProvider>
_subsection: IpcProvider @<IpcProvider> @INHERIT<[[JsonRpcProvider]]> @SRC<providers:class.IpcProvider>
The **IpcProvider** allows the JSON-RPC API to be used over a local
filename on the file system, exposed by Geth, Parity and other nodes.
@ -67,13 +67,13 @@ and may have additional complications due to file permissions. See any
related notes on the documentation for the actual node implementation websites.
_property: ipcProvider.path => string
The path this [[provider]] is connected to.
The path this [[Provider]] is connected to.
_subsection: UrlJsonRpcProvider @<provider-urljsonrpc> @INHERIT<[[provider-jsonrpc]]> @SRC<providers:class.UrlJsonRpcProvider>
_subsection: UrlJsonRpcProvider @<UrlJsonRpcProvider> @INHERIT<[[JsonRpcProvider]]> @SRC<providers:class.UrlJsonRpcProvider>
This class is intended to be sub-classed and not used directly. It
simplifies creating a [[provider]] where a normal [[provider-jsonrpc]]
simplifies creating a [[Provider]] where a normal [[JsonRpcProvider]]
would suffice, with a little extra effort needed to generate the JSON-RPC
URL.
@ -93,12 +93,12 @@ The URL to use for the JsonRpcProvider instance.
_subsection: Web3Provider @<provider-web3> @INHERIT<[[provider-jsonrpc]]>
_subsection: Web3Provider @<Web3Provider> @INHERIT<[[JsonRpcProvider]]>
The Web3Provider is meant to ease moving from a [web3.js based](link-web3)
application to ethers by wraping an existing Web3-compatible (such as a
[Web3HttpProvider](link-web3-http)[Web3IpcProvider](link-web3-ipc) or
[Web3WsProvider](link-web3-ws)) and exposing it as an ethers.js [[provider]]
[Web3WsProvider](link-web3-ws)) and exposing it as an ethers.js [[Provider]]
which can then be used with the rest of the library.
_property: new ethers.providers.Web3Provider(web3Provider [, network ])

187
docs.wrm/api/providers/provider.wrm
View File

@ -1,21 +1,21 @@
_section: Provider @<provider>
_section: Provider @<Provider>
Explain what a provider is...
_subsection: Accounts Methods
_subsection: Accounts Methods @<Provider--account-methods>
_property: provider.getBalance(address [ , blockTag = latest ]) => Promise<[[bignumber]]> @<provider-getbalance> @SRC<providers/base-provider>
_property: provider.getBalance(address [ , blockTag = latest ]) => Promise<[[BigNumber]]> @<Provider-getBalance> @SRC<providers/base-provider>
Returns the balance of //address// as of the //blockTag// block height.
_property: provider.getCode(address [ , blockTag = latest ]) => Promise<string<[[datahexstring]]>> @<providers-getcode> @SRC<providers/base-provider>
_property: provider.getCode(address [ , blockTag = latest ]) => Promise<string<[[DataHexString]]>> @<Provider-getCode> @SRC<providers/base-provider>
Returns the contract code of //address// as of the //blockTag// block height. If there is
no contract currently deployed, the result is ``0x``.
_property: provider.getStorageAt(addr, pos [ , blockTag = latest ]) => Promise<string<[[datahexstring]]>> @<providers-getstorageat> @SRC<providers/base-provider>
_property: provider.getStorageAt(addr, pos [ , blockTag = latest ]) => Promise<string<[[DataHexString]]>> @<Provider-getStorageAt> @SRC<providers/base-provider>
Returns the ``Bytes32`` value of the position //pos// at address //addr//, as of the //blockTag//.
_property: provider.getTransactionCount(address [ , blockTag = latest ]) => Promise<number> @<providers-gettransactioncount> @SRC<providers/base-provider>
_property: provider.getTransactionCount(address [ , blockTag = latest ]) => Promise<number> @<Provider-getTransactionCount> @SRC<providers/base-provider>
Returns the number of transactions //address// has ever **sent**, as of //blockTag//.
This value is required to be the nonce for the next transaction from //address//
sent to the network.
@ -45,27 +45,27 @@ provider.getTransactionCount("ricmoo.firefly.eth");
//!
_subsection: Blocks Methods
_subsection: Blocks Methods @<Provider--block-methods>
_property: provider.getBlock(block) => Promise<[[provider-block]]> @<providers-getblock> @SRC<providers/base-provider>
_property: provider.getBlock(block) => Promise<[[providers-Block]]> @<Provider-getBlock> @SRC<providers/base-provider>
Get the //block// from the network, where the ``result.transactions`` is a list
of transaction hashes.
_property: provider.getBlockWithTransactions(block) => Promise<[[provider-blocktxs]]> @<providers-getblockwithtransactions> @SRC<providers/base-provider>
_property: provider.getBlockWithTransactions(block) => Promise<[[providers-BlockWithTransactions]]> @<Provider-getBlockWithTransactions> @SRC<providers/base-provider>
Get the //block// from the network, where the ``result.transactions`` is
an Array of [[provider-transactionresponse]] objects.
an Array of [[providers-TransactionResponse]] objects.
_subsection: Ethereum Naming Service (ENS) Methods
TODO: Explain ENS here...
_property: provider.lookupAddress(address) => Promise<string> @<providers-lookupaddress> @SRC<providers/base-provider>
_property: provider.lookupAddress(address) => Promise<string> @<Provider-lookupAddress> @SRC<providers/base-provider>
Performs a reverse lookup of the //address// in ENS using the
//Reverse Registrar//. If the name does not exist, or the
forward lookup does not match, ``null`` is returned.
_property: provider.resolveName(name) => Promise<string<[Address](address)>> @<providers-resolvename> @SRC<providers/base-provider>
_property: provider.resolveName(name) => Promise<string<[Address](address)>> @<Provider-ResolveName> @SRC<providers/base-provider>
Looks up the address of //name//. If the name is not owned, or
does not have a //Resolver// configured, or the //Resolver// does
not have an address configured, ``null`` is returned.
@ -87,36 +87,36 @@ provider.resolveName("ricmoo.firefly.eth");
//!
_subsection: Logs Methods
_subsection: Logs Methods @<Provider--log-methods>
_property: provider.getLogs(filter) => Promise<Array<[[provider-log]]>> @<providers-getlogs> @SRC<providers/base-provider>
Returns the Array of [[provider-log]] matching the //filter//.
_property: provider.getLogs(filter) => Promise<Array<[[providers-Log]]>> @<Provider-getLogs> @SRC<providers/base-provider>
Returns the Array of [[providers-Log]] matching the //filter//.
Keep in mind that many backends will discard old events, and that requests
which are too broad may get dropped as they require too many resources to
execute the query.
_subsection: Network Status Methods
_subsection: Network Status Methods @<Provider--network-methods>
_property: provider.getNetwork() => Promise<[[provider-network]]> @<providers-getnetwork> @SRC<providers/base-provider:method.BaseProvider.getNetwork>
Returns the [[provider-network]] this Provider is connected to.
_property: provider.getNetwork() => Promise<[[providers-Network]]> @<Provider-getNetwork> @SRC<providers/base-provider:method.BaseProvider.getNetwork>
Returns the [[providers-Network]] this Provider is connected to.
_property: provider.getBlockNumber() => Promise<number> @<providers-getblocknumber> @SRC<providers/base-provider>
_property: provider.getBlockNumber() => Promise<number> @<Provider-getBlockNumber> @SRC<providers/base-provider>
Returns the block number (or height) of the most recently mined block.
_property: provider.getGasPrice() => Promise<[[bignumber]]> @<providers-getgasprice> @SRC<providers/base-provider>
_property: provider.getGasPrice() => Promise<[[BigNumber]]> @<Provider-getGasPrice> @SRC<providers/base-provider>
Returns a //best guess// of the [[gas-price]] to use in a transaction.
_subsection: Transactions Methods
_subsection: Transactions Methods @<Provider--transaction-methods>
_property: provider.call(transaction [ , blockTag = latest ]) => Promise<string<[[datahexstring]]>> @<providers-call> @SRC<providers/base-provider>
_property: provider.call(transaction [ , blockTag = latest ]) => Promise<string<[[DataHexString]]>> @<Provider-call> @SRC<providers/base-provider>
Returns the result of executing the //transaction//, using //call//. A call
does not require any ether, but cannot change any state. This is useful
for calling gettings on Contracts.
_property: provider.estimateGas(transaction) => Promise<[[bignumber]]> @<providers-estimategas> @SRC<providers/base-provider>
_property: provider.estimateGas(transaction) => Promise<[[BigNumber]]> @<Provider-estimateGas> @SRC<providers/base-provider>
Returns an estimate of the amount of gas that would be required to submit //transaction//
to the network.
@ -124,48 +124,165 @@ An estimate may not be accurate since there could be another transaction
on the network that was not accounted for, but after being mined affected
relevant state.
_property: provider.sendTransaction(transaction) => Promise<[[provider-transactionresponse]]> @<providers-sendtransaction> @SRC<providers/base-provider>
_property: provider.sendTransaction(transaction) => Promise<[[providers-TransactionResponse]]> @<Provider-sendTransaction> @SRC<providers/base-provider>
Submits //transaction// to the network to be mined. The //transaction// **must** be signed,
and be valid (i.e. the nonce is correct and the account has sufficient balance to pay
for the transaction).
_property: provider.waitForTransaction(hash [ , confirms = 1 [ , timeout ] ]) => Promise<[TxReceipt](provider-receipt)> @<providers-waitfortransaction> @SRC<providers/base-provider>
_property: provider.waitForTransaction(hash [ , confirms = 1 [ , timeout ] ]) => Promise<[TxReceipt](providers-TransactionReceipt)> @<Provider-waitForTransaction> @SRC<providers/base-provider>
Returns a Promise which will not resolve until //transactionHash// is mined.
_subsection: Event Emitter Methods
_subsection: Event Emitter Methods @<Provider--event-methods>
Explain events here...
_property: provider.on(eventName, listener) => this @<providers-on> @SRC<providers/base-provider>
_property: provider.on(eventName, listener) => this @<Provider-on> @SRC<providers/base-provider>
Add a //listener// to be triggered for each //eventName//.
_property: provider.once(eventName, listener) => this @<providers-once> @SRC<providers/base-provider>
_property: provider.once(eventName, listener) => this @<Provider-once> @SRC<providers/base-provider>
Add a //listener// to be triggered for only the next //eventName//,
at which time it be removed.
_property: provider.emit(eventName, ...args) => boolean @<providers-emit> @SRC<providers/base-provider>
_property: provider.emit(eventName, ...args) => boolean @<Provider-emit> @SRC<providers/base-provider>
Notify all listeners of //eventName//, passing //args// to each listener. This
is generally only used internally.
_property: provider.off(eventName [ , listener ]) => this @<providers-off> @SRC<providers/base-provider>
_property: provider.off(eventName [ , listener ]) => this @<Provider-off> @SRC<providers/base-provider>
Remove a //listener// for //eventName//. If no //listener// is provided,
all listeners for //eventName// are removed.
_property: provider.removeAllListeners([ eventName ]) => this @<providers-removealllisteners> @SRC<providers/base-provider>
_property: provider.removeAllListeners([ eventName ]) => this @<Provider-removeAllListeners> @SRC<providers/base-provider>
Remove all the listeners for //eventName//. If no //eventName// is provided,
**all** events are removed.
_property: provider.listenerCount([ eventName ]) => number @<providers-listenercount> @SRC<providers/base-provider>
_property: provider.listenerCount([ eventName ]) => number @<Provider-listenerCount> @SRC<providers/base-provider>
Returns the number of listeners for //eventName//. If no //eventName// is
provided, the total number of listeners is returned.
_property: provider.listeners(eventName) => Array<Listener> @<providers-listeners> @SRC<providers/base-provider>
_property: provider.listeners(eventName) => Array<Listener> @<Provider-listeners> @SRC<providers/base-provider>
Returns the list of Listeners for //eventName//.
_subsection: Inspection Methods
_heading: Events @<Provider--events>
_property: Provider.isProvider(object) => boolean @<providers-isprovider> @SRC<abstract-provider>
Any of the following may be used as the //eventName// in the above methods.
_definition: **Log Filter**
A filter is an object, representing a contract log Filter, which has the optional
properties ``address`` (the source contract) and ``topics`` (a topic-set to match).
If ``address`` is unspecified, the filter matches any contract address.
See events for more information on how to specify topic-sets.
_definition: **Topic-Set Filter**
The value of a **Topic-Set Filter** is a array of Topic-Sets.
This event is identical to a //Log Filter// with the address omitted (i.e. from
any contract).
_definition: **Transaction Filter**
The value of a **Transaction Filter** is any transaction hash.
This event is emitted on every block that is part of a chain that
includes the given mined transaction. It is much more common that the
[once](Provider-once) method is used than the [on](Provider-on) method.
_null:
In addition to transaction and filter events, there are several named
events.
_table: Named Provider Events @style<full>
$Block: emitted when a new block is mined
$Error: emitted on any error
$Pending: emitted when a new transaction enters the memory pool; only
certain providers offer this event and may require
running your own node for reliable results
$WillPoll: emitted prior to a polling loop is about to begin;
//(very rarely used by most developers)//
$DidPoll: emitted after all events from a polling loop are emitted;
//(very rarely used by most developers)//
$Poll: emitted during each poll cycle after `blockNumber` is updated
(if changed) and before any other events (if any) are emitted
during the poll loop;
//(very rarely used by most developers)//
$Debug: each Provider may use this to emit useful debugging information
and the format is up to the developer;
//(very rarely used by most developers)//
| **Event Name** | **Arguments** <| **Description** <<<|
| ``"block"`` | //blockNumber// <| $Block <<<|
| ``"error"`` | //error// <| $Error <<<|
| ``"pending"`` | //pendingTransaction// <| $Pending <<<|
| ``"willPoll"`` | //pollId// <| $WillPoll <<<|
| ``"poll"`` | //pollId//, //blockNumber// <| $Poll <<<|
| ``"didPoll"`` | //pollId// <| $DidPoll <<<|
| ``"debug"`` | provider dependent <| $Debug <<<|
_code: Events Example @lang<javasript>
// <hide>
const provider = ethers.getDefaultProvider();
const txHash = utils.id("dummy-data");
// </hide>
provide.on("block", (blockNumber) => {
// Emitted on every block change
})
provider.once(txHash, (transaction) => {
// Emitted when the transaction has been mined
})
// This filter could also be generated with the Contract or
// Interface API. If address is not specified, any address
// matches and if topics is not specified, any log matches
const filter = {
address: "dai.tokens.ethers.eth",
topics: [
utils.id("Transfer(address,address,uint256")
]
}
provider.on(filter, (log, event) => {
// Emitted whenever a DAI token transfer occurs
})
// Notice this is an array of topic-sets and is identical to
// using a filter with no address (i.e. match any address)
const topicSets = [
utils.id("Transfer(address,address,uint256"),
null,
[
myAddress,
myOtherAddress
]
]
provider.on(topicSets, (log, event) => {
// Emitted any token is sent TO either address
})
provider.on("pending", (tx) => {
// Emitted when any new pending transaction is noticed
});
provider.on("error", (tx) => {
// Emitted when any error occurs
});
_subsection: Inspection Methods @<Provider--inspection-methods>
_property: Provider.isProvider(object) => boolean @<Provider-isProvider> @SRC<abstract-provider>
Returns true if and only if //object// is a Provider.

88
docs.wrm/api/providers/types.wrm
View File

@ -1,6 +1,6 @@
_section: Types
_subsection: BlockTag @<provider-blocktag>
_subsection: BlockTag @<providers-BlockTag>
A **BlockTag** specifies a specific location in the Blockchain.
- **``"latest"``** -- The most recently mined block
@ -10,16 +10,16 @@ A **BlockTag** specifies a specific location in the Blockchain.
- **//number//** -- The block at this height
- **//a negative number//** -- The block this many blocks ago
_heading: EventType @<provider-eventtype>
_heading: EventType @<providers-EventType>
And **EventType** can be any of the following.
- **//string//** -- TODO...
- **//Array<string<[[datahexstring]]<32>> | Array<string<[[datahexstring]]<32>>>>//** -- TODO...
- **//[[provider-eventfilter]]//** -- TODO...
- **//Array<string<[[DataHexString]]<32>> | Array<string<[[DataHexString]]<32>>>>//** -- TODO...
- **//[[providers-EventFilter]]//** -- TODO...
_subsection: Network @<provider-network>
_subsection: Network @<providers-Network>
A **Network** represents an Etherem network.
_property: network.name => string
@ -33,12 +33,12 @@ _property: network.ensAddress => string<[[address]]>
The address at which the ENS registry is deployed on this network.
_subsection: Block @<provider-block>
_subsection: Block @<providers-Block>
_property: block.hash => string<[[datahexstring]]<32>>
_property: block.hash => string<[[DataHexString]]<32>>
The hash of this block.
_property: block.parentHash => string<[[datahexstring]]<32>>
_property: block.parentHash => string<[[DataHexString]]<32>>
The hash of the previous block.
_property: block.number => number
@ -47,7 +47,7 @@ The height (number) of this block.
_property: block.timestamp => number
The timestamp of this block.
_property: block.nonce => string<[[datahexstring]]>
_property: block.nonce => string<[[DataHexString]]>
The nonce used as part of the proof-of-work to mine this block.
This property is generally of little interest developers.
@ -57,14 +57,14 @@ The difficulty target required to be met by the miner of the block.
This property is generally of little interest developers.
_property: block.gasLimit => [[bignumber]]
_property: block.gasLimit => [[BigNumber]]
The maximum amount of gas that this block was permitted to use. This
is a value that can be voted up or voted down by miners and is used
to automatically adjust the bandwidth requirements of the network.
This property is generally of little interest developers.
_property: block.gasUsed => [[bignumber]]
_property: block.gasUsed => [[BigNumber]]
The total amount of gas used by all transactions in this block.
_property: block.miner => string
@ -82,51 +82,51 @@ Often only the hashes of the transactions included in a block are needed,
so by default a block only contains this information, as it is
substantially less data.
_property: block.transactions => Array<string<[[datahexstring]]<32>>>
_property: block.transactions => Array<string<[[DataHexString]]<32>>>
A list of the transactions hashes for each transaction this block
includes.
_heading: BlockWithTransactions @<provider-blocktxs> @INHERIT<[Block](provider-block)>
_heading: BlockWithTransactions @<providers-BlockWithTransactions> @INHERIT<[Block](providers-Block)>
If all transactions for a block are needed, this object instead includes
the full details on each transaction.
_property: block.transactions => Array<[[provider-transactionresponse]]>
_property: block.transactions => Array<[[providers-TransactionResponse]]>
A list of the transactions this block includes.
_subsection: Events and Logs
_heading: EventFilter @<provider-eventfilter>
_heading: EventFilter @<providers-EventFilter>
_property: filter.address => string<[[address]]>
The address to filter by, or ``null`` to match any address.
_property: filter.topics => Array<string<[[datahexstring]]<32>> | Array<string<[[datahexstring]]<32>>>>
_property: filter.topics => Array<string<[[DataHexString]]<32>> | Array<string<[[DataHexString]]<32>>>>
The topics to filter by, or ``null`` to match any topics. Each entry represents an
**AND** condition that must match, or may be ``null`` to match anything. If a given
entry is an Array, then that entry is treated as an **OR** for any value in the entry.
_heading: Filter @<provider-filter> @INHERIT<[[provider-eventfilter]]>
_heading: Filter @<providers-Filter> @INHERIT<[[providers-EventFilter]]>
_property: filter.fromBlock => [[provider-blocktag]]
_property: filter.fromBlock => [[providers-BlockTag]]
The starting block (inclusive) to search for logs matching the filter criteria.
_property: filter.toBlock => [[provider-blocktag]]
_property: filter.toBlock => [[providers-BlockTag]]
The end block (inclusive) to search for logs matching the filter criteria.
_heading: FilterByBlockHash @<provider-filterbyblockhash> @INHERIT<[[provider-eventfilter]]>
_heading: FilterByBlockHash @<providers-FilterByBlockHash> @INHERIT<[[providers-EventFilter]]>
_property: filter.blockHash => string<[[datahexstring]]<32>>
_property: filter.blockHash => string<[[DataHexString]]<32>>
The specific block (by its block hash) to search for logs matching the filter criteria.
_heading: Log @<provider-log>
_heading: Log @<providers-Log>
_property: log.blockNumber => number
The block height (number) of the block including the transaction of this log.
_property: log.blockHash => string<[[datahexstring]]<32>>
_property: log.blockHash => string<[[DataHexString]]<32>>
The block hash of the block including the transaction of this log.
_property: log.removed => boolean
@ -141,13 +141,13 @@ The index of this log in the transaction.
_property: log.address => string<[[address]]>
The address of the contract that generated this log.
_property: log.data => string<[[datahexstring]]>
_property: log.data => string<[[DataHexString]]>
The data included in this log.
_property: log.topics => Array<string<[[datahexstring]]<32> > >
_property: log.topics => Array<string<[[DataHexString]]<32> > >
The list of topics (indexed properties) for this log.
_property: log.transactionHash => string<[[datahexstring]]<32>>
_property: log.transactionHash => string<[[DataHexString]]<32>>
The transaction hash of the transaction of this log.
_property: log.transactionIndex => number
@ -159,7 +159,7 @@ The index of this log across all logs in the entire **block**.
_subsection: Transactions
_heading: TransactionRequest @<provider-transactionrequest>
_heading: TransactionRequest @<providers-TransactionRequest>
A transaction request describes a transaction that is to
be sent to the network or otherwise processed.
@ -177,16 +177,16 @@ _property: transactionRequest.nonce => number | Promise<number>
The nonce for this transaction. This should be set to the number of
transactions ever sent **from** this address.
_property: transactionRequest.gasLimit => [[bignumber]] | Promise<[[bignumber]]>
_property: transactionRequest.gasLimit => [[BigNumber]] | Promise<[[BigNumber]]>
The maximum amount of gas this transaction is permitted to use.
_property: transactionRequest.gasPrice => [[bignumber]] | Promise<[[bignumber]]>
_property: transactionRequest.gasPrice => [[BigNumber]] | Promise<[[BigNumber]]>
The price (in wei) per unit of gas this transaction will pay.
_property: transactionRequest.data => [[datahexstring]] | Promise<[[datahexstring]]>
_property: transactionRequest.data => [[DataHexString]] | Promise<[[DataHexString]]>
The transaction data.
_property: transactionRequest.value => [[bignumber]] | Promise<[[bignumber]]>
_property: transactionRequest.value => [[BigNumber]] | Promise<[[BigNumber]]>
The amount (in wei) this transaction is sending.
_property: transactionRequest.chainId => number | Promise<number>
@ -198,16 +198,16 @@ on any network. This can be **dangerous** and care should be taken, since it
allows transactions to be replayed on networks that were possibly not
intended.
_heading: TransactionResponse @INHERIT<[[types-transaction]]> @<provider-transactionresponse>
_heading: TransactionResponse @<providers-TransactionResponse> @INHERIT<[[Transaction]]>
A **TransactionResponse** includes all properties of a [[types-transaction]] as well as several
A **TransactionResponse** includes all properties of a [[Transaction]] as well as several
properties that are useful once it has been mined.
_property: transaction.blockNumber => number
The number ("height") of the block this transaction was mined in. If the block has not been mined,
this is ``null``.
_property: transaction.blockHash => string<[[datahexstring]]<32>>
_property: transaction.blockHash => string<[[DataHexString]]<32>>
The hash of the block this transaction was mined in. If the block has not been mined,
this is ``null``.
@ -219,14 +219,14 @@ _property: transaction.confirmations => number
The number of blocks that have been mined (including the initial block) since this
transaction was mined.
_property: transaction.raw => string<[[datahexstring]]>
_property: transaction.raw => string<[[DataHexString]]>
The serialized transaction.
_property: transaction.wait([ confirmations = 1 ]) => Promise<[[provider-receipt]]> @<transaction>
_property: transaction.wait([ confirmations = 1 ]) => Promise<[[providers-TransactionReceipt]]>
Wait for //confirmations//. If 0, and the transaction has not been mined,
``null`` is returned.
_heading: TransactionReceipt @<provider-receipt>
_heading: TransactionReceipt @<providers-TransactionReceipt>
_property: receipt.to => string<[[address]]>
The address this transaction is to. This is ``null`` if the the
@ -241,7 +241,7 @@ used to deploy a contract, in which case this is the address created by that
contract.
To compute a contract address, the [getContractAddress](utils-getContractAddress)
utility function can also be used with a [[provider-transactionresponse]]
utility function can also be used with a [[providers-TransactionResponse]]
object, which requires the transaction nonce and the address of the sender.
_property: receipt.transactionIndex => number
@ -259,21 +259,21 @@ it could be used to verify a state transition with a fraud-proof
only considering the single transaction; without it the full block
must be considered.
_property: receipt.gasUsed => [[bignumber]]
_property: receipt.gasUsed => [[BigNumber]]
The amount of gas actually used by this transaction.
_property: receipt.logsBloom => string<[[datahexstring]]>
_property: receipt.logsBloom => string<[[DataHexString]]>
A [bloom-filter](link-wiki-bloomfilter), which
incldues all the addresses and topics included in any log in this
transaction.
_property: receipt.blockHash => string<[[datahexstring]]<32>>
_property: receipt.blockHash => string<[[DataHexString]]<32>>
The block hash of the block that this transaction was included in.
_property: receipt.transactionHash => string<[[datahexstring]]<32>>
_property: receipt.transactionHash => string<[[DataHexString]]<32>>
The transaction hash of this transaction.
_property: receipt.logs => Array<[[provider-log]]>
_property: receipt.logs => Array<[[providers-Log]]>
All the logs emitted by this transaction.
_property: receipt.blockNumber => number
@ -284,7 +284,7 @@ _property: receipt.confirmations => number
The number of blocks that have been mined since this transaction,
including the actual block it was mined in.
_property: receipt.cumulativeGasUsed => [[bignumber]]
_property: receipt.cumulativeGasUsed => [[BigNumber]]
For the block this transaction was included in, this is the sum of the
gas used used by each transaction in the ordered list of transactions
up to (and including) this transaction.

82
docs.wrm/api/signer.wrm
View File

@ -1,19 +1,19 @@
_section: Signers
_section: Signers @<signers>
A Signer represents...
_subsection: Signer @<signer> @SRC<abstract-signer:class.Signer>
_subsection: Signer @<Signer> @SRC<abstract-signer:class.Signer>
The **Signer** class is abstract and cannot be directly instaniated. Instead
use one of the concreate sub-classes, such as the [[wallet]], [[void-signer]]
or [[signer-jsonrpc]].
use one of the concreate sub-classes, such as the [[Wallet]], [[VoidSigner]]
or [[JsonRpcSigner]].
_property: signer.connect(provider) => [[signer]] @<signer-connect>
_property: signer.connect(provider) => [[Signer]] @<Signer-connect>
Sub-classes **must** implement this, however they may simply throw an error
if changing providers is not supported.
_property: signer.getAddress() => Promise<string<[Address](address)>> @<signer-getaddress> @SRC<abstract-signer:Signer.connect>
_property: signer.getAddress() => Promise<string<[Address](address)>> @<Signer-getaddress> @SRC<abstract-signer:Signer.connect>
Returns a Promise that resolves to the account address.
This is a Promise so that a **Signer** can be designed around an
@ -21,40 +21,40 @@ asynchronous source, such as hardware wallets.
Sub-classes **must** implement this.
_property: Signer.isSigner(object) => boolean @<signer-issigner> @SRC<abstract-signer>
_property: Signer.isSigner(object) => boolean @<Signer-isSigner> @SRC<abstract-signer>
Returns true if an only if //object// is a **Signer**.
_heading: Blockchain Methods @<signer-blockchain>
_heading: Blockchain Methods @<Signer--blockchain-methods>
_property: signer.getBalance([ blockTag = "latest" ]) => Promise<[[bignumber]]> @<signer-getbalance> @SRC<abstract-signer>
_property: signer.getBalance([ blockTag = "latest" ]) => Promise<[[BigNumber]]> @<Signer-getBalance> @SRC<abstract-signer>
Returns the balance of this wallet at //blockTag//.
_property: signer.getChainId() => Promise<number> @<signer-getchainid> @SRC<abstract-signer>
_property: signer.getChainId() => Promise<number> @<Signer-getChainId> @SRC<abstract-signer>
Returns ths chain ID this wallet is connected to.
_property: signer.getGasPrice() => Promise<[[bignumber]]> @<signer-getgasprice> @SRC<abstract-signer>
_property: signer.getGasPrice() => Promise<[[BigNumber]]> @<Signer-getGasPrice> @SRC<abstract-signer>
Returns the current gas price.
_property: signer.getTransactionCount([ blockTag = "latest" ]) => Promise<number> @<signer-gettransactioncount> @SRC<abstract-signer>
_property: signer.getTransactionCount([ blockTag = "latest" ]) => Promise<number> @<Signer-getTransactionCount> @SRC<abstract-signer>
Returns the number of transactions this account has ever sent. This
is the value required to be included in transactions as the ``nonce``.
_property: signer.call(transactionRequest) => Promise<string<[[datahexstring]]>> @<signer-call> @SRC<abstract-signer>
_property: signer.call(transactionRequest) => Promise<string<[[DataHexString]]>> @<Signer-call> @SRC<abstract-signer>
Returns the result of calling using the //transactionRequest//, with this
account address being used as the ``from`` field.
_property: signer.estimateGas(transactionRequest) => Promise<[[bignumber]]> @<signer-estimategas> @SRC<abstract-signer>
_property: signer.estimateGas(transactionRequest) => Promise<[[BigNumber]]> @<Signer-estimateGas> @SRC<abstract-signer>
Returns the result of estimating the cost to send the //transactionRequest//,
with this account address being used as the ``from`` field.
_property: signer.resolveName(ensName) => Promise<string<[Address](address)>> @<signer-resolvename> @SRC<abstract-signer>
_property: signer.resolveName(ensName) => Promise<string<[Address](address)>> @<Signer-resolveName> @SRC<abstract-signer>
Returns the address associated with the //ensName//.
_heading: Signing
_property: signer.signMessage(message) => Promise<string<[FlatSignature](signature-flat)>> @<signer-signmessage>
This returns a Promise which resolves to the [[signature-flat]]
_property: signer.signMessage(message) => Promise<string<[RawSignature](signature-raw)>> @<Signer-signMessage>
This returns a Promise which resolves to the [[signature-raw]]
of //message//.
Sub-classes **must** implement this, however they may throw if signing a
@ -65,7 +65,7 @@ _note: Note
If //message// is a string, it is **treated as a string** and
converted to its representation in UTF8 bytes.
**If and only if** a message is a [[bytes]] will it be treated as
**If and only if** a message is a [[Bytes]] will it be treated as
binary data.
For example, the string ``"0x1234"`` is 6 characters long (and in
@ -78,21 +78,21 @@ string, it **must** be converted to an array first, using the
_null:
_property: signer.signTransaction(transactionRequest) => Promise<string<[[datahexstring]]>> @<signer-signtransaction>
_property: signer.signTransaction(transactionRequest) => Promise<string<[[DataHexString]]>> @<Signer-signTransaction>
Returns a Promise which resolves to the signed transaction of the
//transactionRequest//. This method does not populate any missing fields.
Sub-classes **must** implement this, however they may throw if signing a
transaction is not supported.
_property: signer.sendTransaction(transactionRequest) => Promise<[[provider-transactionresponse]]> @<signer-sendtransaction>
_property: signer.sendTransaction(transactionRequest) => Promise<[[providers-TransactionResponse]]> @<Signer-sendTransaction>
This method populates the transactionRequest with missing fields, using
[populateTransaction](signer-populatetransaction) and returns a Promise which resolves to the transaction.
[populateTransaction](Signer-populateTransaction) and returns a Promise which resolves to the transaction.
Sub-classes **must** implement this, however they may throw if signing a
transaction is not supported.
_heading: Sub-Classes @<signer-subclassing>
_heading: Sub-Classes @<Signer--subclassing>
It is very important that all important properties of a **Signer** are
**immutable**. Since Ethereum is very asynchronous and deals with critical
@ -102,7 +102,7 @@ serious issues.
A sub-class **must** call ``super()``.
_property: signer.checkTransaction(transactionRequest) => [[provider-transactionrequest]] @<signer-checktransaction> @SRC<abstract-signer>
_property: signer.checkTransaction(transactionRequest) => [[providers-TransactionRequest]] @<Signer-checkTransaction> @SRC<abstract-signer>
This is generally not required to be overridden, but may needed to provide
custom behaviour in sub-classes.
@ -110,11 +110,11 @@ This should return a **copy** of the //transactionRequest//, with any properties
needed by ``call``, ``estimateGas`` and ``populateTransaction`` (which is used
by sendTransaction). It should also throw an error if any unknown key is specified.
The default implementation checks only valid [[provider-transactionrequest]] properties
The default implementation checks only valid [[providers-TransactionRequest]] properties
exist and adds ``from`` to the transaction if it does not exist, or verifies it is equal
to the Signer's address if it does exist.
_property: signer.populateTransaction(transactionRequest) => Promise<[[provider-transactionrequest]]> @<signer-populatetransaction> @SRC<abstract-signer>
_property: signer.populateTransaction(transactionRequest) => Promise<[[providers-TransactionRequest]]> @<Signer-populateTransaction> @SRC<abstract-signer>
This is generally not required to be overridden, but may needed to provide
custom behaviour in sub-classes.
@ -127,33 +127,33 @@ The default implementation calls ``checkTransaction`` and resolves to if it is a
ENS name, adds ``gasPrice``, ``nonce``, ``gasLimit`` and ``chainId`` based on the
related operations on Signer.
_subsection: Wallet @<wallet> @INHERIT<[[externally-owned-account]] and [[signer]]> @SRC<wallet:class.Wallet>
_subsection: Wallet @<Wallet> @INHERIT<[[ExternallyOwnedAccount]] and [[Signer]]> @SRC<wallet:class.Wallet>
The Wallet class inherits [[signer]] and can sign transactions and messages
The Wallet class inherits [[Signer]] and can sign transactions and messages
using a private key as a standard Externally Owned Account (EOA).
_property: new ethers.Wallet(privateKey [ , provider ]) @<wallet-constructor> @SRC<wallet:constructor.Wallet>
_property: new ethers.Wallet(privateKey [ , provider ]) @<Wallet-constructor> @SRC<wallet:constructor.Wallet>
Create a new Wallet instance for //privateKey// and optionally
connected to the //provider//.
_property: ethers.Wallet.createRandom( [ options = { } ]) => [[wallet]] @<wallet-createrandom> @SRC<wallet>
_property: ethers.Wallet.createRandom( [ options = { } ]) => [[Wallet]] @<Wallet-createRandom> @SRC<wallet>
Returns a new Wallet with a random private key, generated from
cryptographically secure entropy sources. If the current environment
does not have a secure entropy source, an error is thrown.
_property: ethers.Wallet.fromEncryptedJson(json, password [ , progress ]) => Promise<[[wallet]]> @<wallet-fromencryptedjson> @SRC<wallet>
_property: ethers.Wallet.fromEncryptedJson(json, password [ , progress ]) => Promise<[[Wallet]]> @<Wallet-fromEncryptedJson> @SRC<wallet>
Create an instance from an encrypted JSON wallet. If //progress//
is provided it will be called during decryption with a value between 0 and
1 indicating the progress towards completion.
_property: ethers.Wallet.fromEncryptedJsonSync(json, password) => [[wallet]] @<wallet-fromencryptedjsonsync> @SRC<wallet>
_property: ethers.Wallet.fromEncryptedJsonSync(json, password) => [[Wallet]] @<Wallet-fromEncryptedJsonSync> @SRC<wallet>
Create an instance from an encrypted JSON wallet.
This operation will operate synchronously which will lock up the user
interface, possibly for a non-trivial duration. Most applications should
use the asynchronous ``fromEncryptedJson`` instead.
_property: ethers.Wallet.fromMnemonic(mnemonic [ , path, [ wordlist ] ]) => [[wallet]]
_property: ethers.Wallet.fromMnemonic(mnemonic [ , path, [ wordlist ] ]) => [[Wallet]]
Create an instance from a mnemonic phrase.
If path is not specified, the Ethereum default path is used (i.e. m/44'/60'/0'/0/0).
@ -165,16 +165,16 @@ _heading: Properties
_property: wallet.address => string<[Address](address)>
The address for the account this Wallet represents.
_property: wallet.provider => [[provider]]
The provider this wallet is connected to, which will ge used for any [[signer-blockchain]]
_property: wallet.provider => [[Provider]]
The provider this wallet is connected to, which will ge used for any [[Signer--blockchain-methods]]
methods. This can be null.
_note: Note
A **Wallet** instance is immuatable, so if you wish to change the Provider, you
may use the [connect](signer-connect) method to create a new instance connected
may use the [connect](Signer-connect) method to create a new instance connected
to the desired provider.
_property: wallet.publicKey => string<[[datahexstring]]<65>>
_property: wallet.publicKey => string<[[DataHexString]]<65>>
The uncompressed public key for this Wallet represents.
_heading: Methods
@ -185,7 +185,7 @@ Encrypt the wallet using //password// returning a Promise which resolves
to a JSON wallet.
_subsection: VoidSigner @<void-signer> @INHERIT<[[signer]]> @SRC<abstract-signer:class.VoidSigner>
_subsection: VoidSigner @<VoidSigner> @INHERIT<[[Signer]]> @SRC<abstract-signer:class.VoidSigner>
A **VoidSigner** is a simple Signer which cannot sign.
@ -196,14 +196,14 @@ will be carried.
For example, the ``call`` operation will automatically have the
provided address passed along during the execution.
_property: new ethers.VoidSigner(address) => [[void-signer]]
_property: new ethers.VoidSigner(address) => [[VoidSigner]]
Create a new instance of a **VoidSigner** for //address//.
_property: voidSigner.address => string<[Address](address)>
The address of this **VoidSigner**.
_subsection: ExternallyOwnedAccount @<externally-owned-account>
_subsection: ExternallyOwnedAccount @<ExternallyOwnedAccount>
This is an interface which contains a minimal set of properties
required for Externally Owned Accounts which can have certain
@ -213,11 +213,11 @@ _property: eoa.address => string<[Address](address)>
The [[address]] of this EOA.
_property: eoa.privateKey => string<[[datahexstring]]<32>>
_property: eoa.privateKey => string<[[DataHexString]]<32>>
The privateKey of this EOA
_property: eoa.mnemonic => [[hdnode-mnemonic]]
_property: eoa.mnemonic => [[Mnemonic]]
//Optional//. The account HD mnemonic, if it has one and can be
determined. Some sources do not encode the mnemonic, such as an

78
docs.wrm/api/utils/abi/fragments.wrm
View File

@ -1,4 +1,4 @@
_section: Fragments
_section: Fragments @<fragments>
Explain an ABI.
@ -10,7 +10,7 @@ The **JSON ABI Format** is the format that is
[output from the Solidity compiler](link-solc-output).
A JSON serialized object is always a string, which represents an Array
of Objects, where each Object has various properties describing the [[abi-fragment]] of the ABI.
of Objects, where each Object has various properties describing the [[Fragment]] of the ABI.
The deserialied JSON string (which is a normal JavaScript Object) may
also be passed into any function which accepts a JSON String ABI.
@ -22,9 +22,9 @@ The Human-Readable ABI was
[article](link-ricmoo-humanreadableabi)
_heading: Output Formats @<abi-outputformats> @SRC<abi/fragments:FormatTypes>
_heading: Output Formats @<fragments--output-formats> @SRC<abi/fragments:FormatTypes>
Each [[abi-fragment]] and [[abi-paramtype]] may be output using its ``format``
Each [[Fragment]] and [[ParamType]] may be output using its ``format``
method.
_property: ethers.utils.FragmentTypes.full => string
@ -37,7 +37,7 @@ _property: ethers.utils.FragmentTypes.minimal => string
This is similar to ``full``, except with no unnecessary whitespace or parameter
names. This is useful for storing a minimal string which can still fully
reconstruct the original Fragment using [Fragment&thinsp;.&thinsp;from](abi-fragment-from).
reconstruct the original Fragment using [Fragment&thinsp;.&thinsp;from](Fragment-from).
_property: ethers.utils.FragmentTypes.json => string
@ -51,55 +51,55 @@ signature hash or an event topic hash.
_warning: Note
The ``sighash`` format is **insufficient** to re-create the original [[abi-fragment]],
The ``sighash`` format is **insufficient** to re-create the original [[Fragment]],
since it discards modifiers such as indexed, anonymous, stateMutability, etc.
_subsection: Fragment @<abi-fragment> @SRC<abi/fragments:class.Fragment>
_subsection: Fragment @<Fragment> @SRC<abi/fragments:class.Fragment>
An ABI is a collection of **Fragments**, where each fragment specifies:
- An [Event](abi-eventfragment)
- A [Function](abi-functionfragment)
- A [Constructor](abi-constructorfragment)
- An [Event](EventFragment)
- A [Function](FunctionFragment)
- A [Constructor](ConstructorFragment)
_heading: Properties
_property: fragment.name => string
This is the name of the Event or Function. This will be null for
a [[abi-constructorfragment]].
a [[ConstructorFragment]].
_property: fragment.type => string
This is a string which indicates the type of the [[abi-fragment]]. This
This is a string which indicates the type of the [[Fragment]]. This
will be one of:
- ``constructor``
- ``event``
- ``function``
_property: fragment.inputs => Array<[[abi-paramtype]]>
_property: fragment.inputs => Array<[[ParamType]]>
This is an array of of each [[abi-paramtype]] for the input parameters to
This is an array of of each [[ParamType]] for the input parameters to
the Constructor, Event of Function.
_heading: Methods
_property: ethers.utils.Fragment.from(objectOrString) => [[abi-fragment]] @<abi-fragment-from> @SRC<abi/fragments:Fragment.from>
_property: ethers.utils.Fragment.from(objectOrString) => [[Fragment]] @<Fragment-from> @SRC<abi/fragments:Fragment.from>
Returns a
_property: ethers.utils.Fragment.isFragment(object) => boolean @<abi-isfragment> @SRC<abi/fragments:Fragment.isFragment>
_property: ethers.utils.Fragment.isFragment(object) => boolean @<Fragment-isFragment> @SRC<abi/fragments:Fragment.isFragment>
Tra lal al
_subsection: ConstructorFragment @<abi-constructorfragment> @INHERIT<[[abi-fragment]]> @SRC<abi/fragments:class.ConstructorFragment>
_subsection: ConstructorFragment @<ConstructorFragment> @INHERIT<[[Fragment]]> @SRC<abi/fragments:class.ConstructorFragment>
_heading: Properties
_property: fragment.gas => [[bignumber]]
_property: fragment.gas => [[BigNumber]]
This is the gas limit that should be used during deployment. It may be
null.
@ -118,16 +118,16 @@ This is the state mutability of the constructor. It can be any of:
_heading: Methods
_property: ethers.utils.ConstructorFragment.from(objectOrString) => [[abi-constructorfragment]] @<abi-constructorfragment-from> @SRC<abi/fragments:ConstructorFragment.from>
_property: ethers.utils.ConstructorFragment.from(objectOrString) => [[ConstructorFragment]] @<ConstructorFragment-from> @SRC<abi/fragments:ConstructorFragment.from>
Tra la la...
_property: ethers.utils.ConstructorFragment.isConstructorFragment(object) => boolean @<abi-isconstructorfragment> @SRC<abi/fragments:ConstructorFragment.isConstructorFragment>
_property: ethers.utils.ConstructorFragment.isConstructorFragment(object) => boolean @<ConstructorFragment-isConstructorFragment> @SRC<abi/fragments:ConstructorFragment.isConstructorFragment>
Tra lal al
_subsection: EventFragment @<abi-eventfragment> @INHERIT<[[abi-fragment]]> @SRC<abi/fragments:class.EventFragment>
_subsection: EventFragment @<EventFragment> @INHERIT<[[Fragment]]> @SRC<abi/fragments:class.EventFragment>
_heading: Properties
@ -138,16 +138,16 @@ topic hash as topic0 when creating a log.
_heading: Methods
_property: ethers.utils.EventFragment.from(objectOrString) => [[abi-eventfragment]] @<abi-eventfragment-from> @SRC<abi/fragments:EventFragment.from>
_property: ethers.utils.EventFragment.from(objectOrString) => [[EventFragment]] @<EventFragment-from> @SRC<abi/fragments:EventFragment.from>
Tra la la...
_property: ethers.utils.EventFragment.isEventFragment(object) => boolean @<abi-iseventfragment> @SRC<abi/fragments:EventFragment.isEventFragment>
_property: ethers.utils.EventFragment.isEventFragment(object) => boolean @<EventFragment-isEventFragment> @SRC<abi/fragments:EventFragment.isEventFragment>
Tra lal al
_subsection: FunctionFragment @<abi-functionfragment> @INHERIT<[[abi-constructorfragment]]> @SRC<abi/fragments:class.FunctionFragment>
_subsection: FunctionFragment @<FunctionFragment> @INHERIT<[[ConstructorFragment]]> @SRC<abi/fragments:class.FunctionFragment>
_heading: Properties
@ -165,22 +165,22 @@ This is the state mutability of the constructor. It can be any of:
- ``pure``
- ``view``
_property: fragment.outputs => Array<[[abi-paramtype]]>
_property: fragment.outputs => Array<[[ParamType]]>
A list of the Function output parameters.
_heading: Method
_property: ethers.utils.FunctionFragment.from(objectOrString) => [[abi-functionfragment]] @<abi-functionfragment-from> @SRC<abi/fragments:ConstructorFragment.from>
_property: ethers.utils.FunctionFragment.from(objectOrString) => [[FunctionFragment]] @<FunctionFragment-from> @SRC<abi/fragments:ConstructorFragment.from>
Tra la la...
_property: ethers.utils.FunctionFragment.isFunctionFragment(object) => boolean @<abi-isfunctionfragment> @SRC<abi/fragments:FunctionFragment.isFunctionFragment>
_property: ethers.utils.FunctionFragment.isFunctionFragment(object) => boolean @<FunctionFragment-isFunctionFragment> @SRC<abi/fragments:FunctionFragment.isFunctionFragment>
Tra lal al
_subsection: ParamType @<abi-paramtype> @SRC<abi/fragments:class.ParamType>
_subsection: ParamType @<ParamType> @SRC<abi/fragments:class.ParamType>
The following examples will represent the Solidity parameter:
@ -188,38 +188,38 @@ The following examples will represent the Solidity parameter:
_heading: Properties
_property: paramType.name => string @<abi-paramtype-name>
_property: paramType.name => string @<ParamType-name>
The local parameter name. This may be null for unnamed parameters. For example,
the parameter definition ``string foobar`` would be ``foobar``.
_property: paramType.type => string @<abi-paramtype-type>
_property: paramType.type => string @<ParamType-type>
The full type of the parameter, including tuple and array symbols. This may be null
for unnamed parameters. For the above example, this would be ``foobar``.
_property: paramType.basetype => string @<abi-paramtype-basetype>
_property: paramType.baseType => string @<ParamType-baseType>
The base type of the parameter. For primitive types (e.g. ``address``, ``uint256``, etc)
this is equal to [type](abi-paramtype-type). For arrays, it will be the string ``array`` and for
this is equal to [type](ParamType-type). For arrays, it will be the string ``array`` and for
a tuple, it will be the string ``tuple``.
_property: paramType.indexed => boolean @<abi-paramtype-indexed>
_property: paramType.indexed => boolean @<ParamType-indexed>
Whether the parameter has been marked as indexed. This **only** applies
to parameters which are part of an [[abi-eventfragment]].
to parameters which are part of an [[EventFragment]].
_property: paramType.arrayChildren => [[abi-paramtype]] @<abi-paramtype-arraychildren>
_property: paramType.arrayChildren => [[ParamType]] @<ParamType-arrayChildren>
The type of children of the array. This is null for for any parameter
wjhich is not an array.
_property: paramType.arrayLength => number @<abi-paramtype-arraylength>
_property: paramType.arrayLength => number @<ParamType-arrayLength>
The length of the array, or ``-1`` for dynamic-length arrays. This is
null for parameters which is not arrays.
_property: paramType.components => Array<[[abi-paramtype]]> @<abi-paramtype-components>
_property: paramType.components => Array<[[ParamType]]> @<ParamType-components>
The components of a tuple. This is null for non-tuple parameters.
@ -232,10 +232,10 @@ _property: paramType.format([ outputType = sighash ])
Tra la la...
_property: ethers.utils.ParamType.from(objectOrString) => [[abi-paramtype]] @<abi-paramtype-from> @SRC<abi/fragments:ParamType.from>
_property: ethers.utils.ParamType.from(objectOrString) => [[ParamType]] @<ParamType-from> @SRC<abi/fragments:ParamType.from>
Tra la la...
_property: ethers.utils.ParamType.isParamType(object) => boolean @<abi-paramtype-isparamtype> @SRC<abi/fragments:ParamType.isParamType>
_property: ethers.utils.ParamType.isParamType(object) => boolean @<ParamType-isParamType> @SRC<abi/fragments:ParamType.isParamType>
Tra la la...

6
docs.wrm/api/utils/abi/index.wrm
View File

@ -1,16 +1,16 @@
_section: Application Binary Interface @NAV<ABI>
An **Application Binary Interface** (ABI) is a collection of
[Fragments](abi-fragment) which specify how to interact with
[Fragments](Fragment) which specify how to interact with
various components of a Contract.
An [[abi-interface]] helps organize Fragments by type as well
An [[Interface]] helps organize Fragments by type as well
as provides the functionality required to encode, decode and
work with each component.
Most developers will not require this low-level access to encoding
and decoding the binary data on the network and will most likely
use a [[contract]] which provides a more convenient interface. Some
use a [[Contract]] which provides a more convenient interface. Some
framework, tool developers or developers using advanced techniques
may find these classes and utilities useful.

88
docs.wrm/api/utils/abi/interface.wrm
View File

@ -1,4 +1,4 @@
_section: Interface @<abi-interface> @SRC<abi/interface:class.Interface>
_section: Interface @<Interface> @SRC<abi/interface:class.Interface>
The **Interface** Class abstracts the encoding and decoding required
to interact with contracts on the Ethereum network.
@ -28,17 +28,17 @@ within the same source file.
_subsection: Properties
_property: interface.fragments => Array<[[abi-fragment]]>
All the [Fragments](abi-fragment) in the interface.
_property: interface.fragments => Array<[[Fragment]]>
All the [Fragments](Fragment) in the interface.
_property: interface.events => Array<[[abi-eventfragment]]>
All the [Event Fragments](abi-eventfragment) in the interface.
_property: interface.events => Array<[[EventFragment]]>
All the [Event Fragments](EventFragment) in the interface.
_property: interface.functions => Array<[[abi-functionfragment]]>
All the [Function Fragments](abi-functionfragment) in the interface.
_property: interface.functions => Array<[[FunctionFragment]]>
All the [Function Fragments](FunctionFragment) in the interface.
_property: interface.deploy => [[abi-constructorfragment]]
The [Constructor Fragments](abi-constructorfragment) for the interface.
_property: interface.deploy => [[ConstructorFragment]]
The [Constructor Fragments](ConstructorFragment) for the interface.
_subsection: Formatting
@ -51,65 +51,65 @@ strings is returned.
_subsection: Fragment Access
_property: interface.getFunction(fragment) => [[abi-functionfragment]] @SRC<abi/interface>
Returns the [[abi-functionfragment]] for //fragment// (see [[abi-fragmentid]]).
_property: interface.getFunction(fragment) => [[FunctionFragment]] @SRC<abi/interface>
Returns the [[FunctionFragment]] for //fragment// (see [[Interface--specifying-fragments]]).
_property: interface.getEvent(fragment) => [[abi-eventfragment]] @SRC<abi/interface>
Returns the [[abi-eventfragment]] for //fragment// (see [[abi-fragmentid]]).
_property: interface.getEvent(fragment) => [[EventFragment]] @SRC<abi/interface>
Returns the [[EventFragment]] for //fragment// (see [[Interface--specifying-fragments]]).
_subsection: Signature and Topic Hashes
_property: interface.getSighash(fragment) => string<[[datahexstring]]<4>> @SRC<abi/interface:method.Interface.getSighash>
Return the sighash (or Function Selector) for //fragment// (see [[abi-fragmentid]]).
_property: interface.getSighash(fragment) => string<[[DataHexString]]<4>> @SRC<abi/interface:method.Interface.getSighash>
Return the sighash (or Function Selector) for //fragment// (see [[Interface--specifying-fragments]]).
_property: interface.getEventTopic(fragment) => string<[[datahexstring]]<32>> @SRC<abi/interface:method.Interface.getEventTopic>
Return the topic hash for //fragment// (see [[abi-fragmentid]]).
_property: interface.getEventTopic(fragment) => string<[[DataHexString]]<32>> @SRC<abi/interface:method.Interface.getEventTopic>
Return the topic hash for //fragment// (see [[Interface--specifying-fragments]]).
_subsection: Encoding Data
_property: interface.encodeDeploy([ values ]) => string<[[datahexstring]]> @SRC<abi/interface>
_property: interface.encodeDeploy([ values ]) => string<[[DataHexString]]> @SRC<abi/interface>
Return the encoded deployment data, which can be concatenated to the
deployment bytecode of a contract to pass //values// into the contract
constructor.
_property: interface.encodeFilterTopics(fragment [ , values ]) => Array<topic | Array<topic>> @SRC<abi/interface>
Returns the encoded topic filter, which can be passed to getLogs for //fragment//
(see [[abi-fragmentid]]) for the given //values//.
(see [[Interface--specifying-fragments]]) for the given //values//.
Each //topic// is a 32 byte (64 nibble) [[datahexstring]].
Each //topic// is a 32 byte (64 nibble) [[DataHexString]].
_property: interface.encodeFunctionData(fragment [ , values ]) => string<[[datahexstring]]> @SRC<abi/interface>
_property: interface.encodeFunctionData(fragment [ , values ]) => string<[[DataHexString]]> @SRC<abi/interface>
Returns the encoded data, which can be used as the data for a transaction for
//fragment// (see [[abi-fragmentid]]) for the given //values//.
//fragment// (see [[Interface--specifying-fragments]]) for the given //values//.
_property: interface.encodeFunctionResult(fragment [ , values ]) => string<[[datahexstring]]> @SRC<abi/interface>
_property: interface.encodeFunctionResult(fragment [ , values ]) => string<[[DataHexString]]> @SRC<abi/interface>
Returns the encoded result, which would normally be the response from a call for
//fragment// (see [[abi-fragmentid]]) for the given //values//.
//fragment// (see [[Interface--specifying-fragments]]) for the given //values//.
Most developers will not need this method, but may be useful for authors of a mock blockchain.
_subsection: Decoding Data
_property: interface.decodeEventLog(fragment, data [ , topics ]) => [[abi-result]] @SRC<abi/interface>
_property: interface.decodeEventLog(fragment, data [ , topics ]) => [[Result]] @SRC<abi/interface>
Returns the decoded event values from an event log for
//fragment// (see [[abi-fragmentid]]) for the given //data//
//fragment// (see [[Interface--specifying-fragments]]) for the given //data//
with the optional //topics//.
If //topics// is not specified, placeholders will be inserted into the result.
_property: interface.decodeFunctionData(fragment, data) => [[abi-result]] @SRC<abi/interface>
_property: interface.decodeFunctionData(fragment, data) => [[Result]] @SRC<abi/interface>
Returns the decoded values from transaction data for
//fragment// (see [[abi-fragmentid]]) for the given //data//.
//fragment// (see [[Interface--specifying-fragments]]) for the given //data//.
Most developers will not need this method, but may be useful for debugging
or inspecting transactions.
_property: interface.decodeFunctionResult(fragment, data) => [[abi-result]] @SRC<abi/interface>
_property: interface.decodeFunctionResult(fragment, data) => [[Result]] @SRC<abi/interface>
Returns the decoded values from the result of a call for
//fragment// (see [[abi-fragmentid]]) for the given //data//.
//fragment// (see [[Interface--specifying-fragments]]) for the given //data//.
_subsection: Parsing
@ -118,18 +118,18 @@ The functions are generally the most useful for most developers. They will
automatically search the ABI for a matching Event or Function and decode
the components as a fully specified description.
_property: interface.parseLog(log) => [[abi-log]] @SRC<abi/interface>
_property: interface.parseLog(log) => [[LogDescription]] @SRC<abi/interface>
Search the event that matches the //log// topic hash and parse the values
the log represents.
_property: interface.parseTransaction(transaction) => [[abi-transaction]] @SRC<abi/interface>
_property: interface.parseTransaction(transaction) => [[TransactionDescription]] @SRC<abi/interface>
Search for the function that matches the //transaction// data sighash
and parse the transaction properties.
_subsection: Types
_heading: Result @<abi-result> @INHERIT<Array&lt;any&gt;>
_heading: Result @<Result> @INHERIT<Array\<any\>>
A **Result** is an array, so each value can be accessed as a positional
argument.
@ -142,13 +142,13 @@ any named value for this key is renamed to ``_length``. If there is a
name collision, only the first is available by its key.
_heading: LogDescription @<abi-log>
_heading: LogDescription @<LogDescription>
_property: logDescription.args => [[abi-result]]
_property: logDescription.args => [[Result]]
The values of the input parameters of the event.
_property: logDescription.eventFragment => [[abi-eventfragment]]
The [[abi-eventfragment]] which matches the topic in the Log.
_property: logDescription.eventFragment => [[EventFragment]]
The [[EventFragment]] which matches the topic in the Log.
_property: logDescription.name => string
The event name. (e.g. ``Transfer``)
@ -160,14 +160,14 @@ _property: logDescription.topic => string
The topic hash.
_heading: TransactionDescription @<abi-transaction>
_heading: TransactionDescription @<TransactionDescription>
_property: transactionDescription.args => [[abi-result]]
_property: transactionDescription.args => [[Result]]
The decoded values from the transaction data which were passed
as the input parameters.
_property: transactionDescription.functionFragment => [[abi-functionfragment]]
The [[abi-functionfragment]] which matches the sighash in the transaction data.
_property: transactionDescription.functionFragment => [[FunctionFragment]]
The [[FunctionFragment]] which matches the sighash in the transaction data.
_property: transactionDescription.name => string
The name of the function. (e.g. ``transfer``)
@ -178,11 +178,11 @@ The sighash (or function selector) that matched the transaction data.
_property: transactionDescription.signature => string
The signature of the function. (e.g. ``transfer(address,uint256)``)
_property: transactionDescription.value => [[bignumber]]
_property: transactionDescription.value => [[BigNumber]]
The value from the transaction.
_subsection: Specifying Fragments @<abi-fragmentid>
_subsection: Specifying Fragments @<Interface--specifying-fragments>
When specifying a fragment to any of the functions in an **Interface**,
any of the following may be used:
@ -193,4 +193,4 @@ any of the following may be used:
so, for example, ``uint`` and ``uint256`` are equivalent (e.g. ``transfer(address, uint)``)
- The **sighash** or **topichash** of the function. The sighash is often referred
to the function selector in Solidity (e.g. ``0xa9059cbb``)
- A [[abi-fragment]]
- A [[Fragment]]

8
docs.wrm/api/utils/address.wrm
View File

@ -9,7 +9,7 @@ _subsection: Address Formats @<address-formats>
_heading: Address @<address>
An **Address** is a [[datahexstring]] of 20 bytes (40 nibbles), with optional
An **Address** is a [[DataHexString]] of 20 bytes (40 nibbles), with optional
mixed case.
If the case is mixed, it is a **Checksum Address**, which uses a specific pattern
@ -39,12 +39,12 @@ accepts an address can receive an ICAP address, and it will be converted interna
To convert an address into the ICAP format, see [getIcapAddress](utils-getIcapAddress).
_subsection: Converting and Verifying @<urils--address-basic>
_subsection: Converting and Verifying @<utils--address>
_property: ethers.utils.getAddress(address) => string<[[address]]> @<utils-getAddress> @SRC<address>
Returns //address// as a Checksum Address.
If //address// is an invalid 40-nibble [[hexstring]] or if it contains mixed case and
If //address// is an invalid 40-nibble [[HexString]] or if it contains mixed case and
the checksum is invalid, an InvalidArgument Error is throw.
The value of //address// may be any supported address format.
@ -57,7 +57,7 @@ _property: ethers.utils.isAddress(address) => boolean @<utils-isAddress> @SRC<a
Returns true if //address// is valid (in any supported format).
_subsection: Derivation @<utils--address-computation>
_subsection: Derivation @<utils--address-derivation>
_property: ethers.utils.computeAddress(publicOrPrivateKey) => string<[[address]]> @<utils-computeAddress> @SRC<transactions>
Returns the address for //publicOrPrivateKey//. A public key may be

118
docs.wrm/api/utils/bignumber.wrm
View File

@ -1,7 +1,7 @@
_section: BigNumber @<bignumber>
_section: BigNumber @<BigNumber>
Many operations in Ethereum operation on numbers which are
[outside the range of safe values](notes-safenumbers) to use
[outside the range of safe values](BigNumber--notes-safenumbers) to use
in JavaScript.
A **BigNumber** is an object which safely allows mathematic operations
@ -18,8 +18,8 @@ _code: CommonJS @lang<script>
// From the Umbrella ethers package...
const { BigNumber } = require("ethers");
// From the bignumber pacakge...
const { BigNumber } = require("@ethersproject/bignumber");
// From the BigNumber pacakge...
const { BigNumber } = require("@ethersproject/BigNumber");
_code: ES6 and TypeScript CommonJS @lang<script>
@ -27,27 +27,27 @@ _code: ES6 and TypeScript CommonJS @lang<script>
// From the Umbrella ethers package...
import { BigNumber } from "ethers";
// From the bignumber pacakge...
import { BigNumber } from "@ethersproject/bignumber";
// From the BigNumber pacakge...
import { BigNumber } from "@ethersproject/BigNumber";
_subsection: Types
_heading: BigNumberish @<bignumberish>
_heading: BigNumberish @<BigNumberish>
Many functions and methods in this library take in values which
can be non-ambiguously and safely converted to a BigNumber. These
values can be sepcified as:
_definition: **//string//**
A [hexstring](hexstring) or a decimal string, either of which may
A [[HexString]] or a decimal string, either of which may
be negative.
_definition: **//BytesLike//**
A [BytesLike](byteslike) Object, such as an Array or Uint8Array.
A [[BytesLike]] Object, such as an Array or Uint8Array.
_definition: **//BigNumber//**
An existing [[bignumber]] instance.
An existing [[BigNumber]] instance.
_definition: **//number//**
A number that is within the [safe range](link-js-maxsafe) for JavaScript numbers.
@ -61,7 +61,7 @@ _subsection: Creating Instances
The constructor of BigNumber cannot be called directly. Instead, Use the static ``BigNumber.from``.
_property: ethers.BigNumber.from(aBigNumberish) => [[bignumber]]
_property: ethers.BigNumber.from(aBigNumberish) => [[BigNumber]]
Returns an instance of a **BigNumber** for //aBigNumberish//.
_heading: Examples: @<>
@ -72,11 +72,11 @@ _code: @lang<javascript>
BigNumber.from("42")
//!
// From a hexstring...
// From a HexString...
BigNumber.from("0x2a")
//!
// From a negative hexstring...
// From a negative HexString...
BigNumber.from("-0x2a")
//!
@ -116,29 +116,29 @@ it represents.
_heading: Math Operations
_property: bignumber.add(otherValue) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// **+** //otherValue//.
_property: BigNumber.add(otherValue) => [[BigNumber]] @SRC<bignumber>
Returns a BigNumber with the value of //BigNumber// **+** //otherValue//.
_property: bignumber.sub(otherValue) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// **-** //otherValue//.
_property: BigNumber.sub(otherValue) => [[BigNumber]] @SRC<bignumber>
Returns a BigNumber with the value of //BigNumber// **-** //otherValue//.
_property: bignumber.mul(otherValue) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// **&times;** //otherValue//.
_property: BigNumber.mul(otherValue) => [[BigNumber]] @SRC<bignumber>
Returns a BigNumber with the value of //BigNumber// **&times;** //otherValue//.
_property: bignumber.div(divisor) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// **&div;** //divisor//.
_property: BigNumber.div(divisor) => [[BigNumber]] @SRC<bignumber>
Returns a BigNumber with the value of //BigNumber// **&div;** //divisor//.
_property: bignumber.mod(divisor) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of the **remainder** of //bignumber// &div; //divisor//.
_property: BigNumber.mod(divisor) => [[BigNumber]] @SRC<bignumber>
Returns a BigNumber with the value of the **remainder** of //BigNumber// &div; //divisor//.
_property: bignumber.pow(exponent) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// to the power of //exponent//.
_property: BigNumber.pow(exponent) => [[BigNumber]] @SRC<bignumber>
Returns a BigNumber with the value of //BigNumber// to the power of //exponent//.
_property: bignumber.abs() => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the absolute value of //bignumber//.
_property: BigNumber.abs() => [[BigNumber]] @SRC<bignumber>
Returns a BigNumber with the absolute value of //BigNumber//.
_property: bignumber.mask(bitcount) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// with bits beyond
_property: BigNumber.mask(bitcount) => [[BigNumber]] @SRC<bignumber>
Returns a BigNumber with the value of //BigNumber// with bits beyond
the //bitcount// least significant bits set to zero.
@ -149,48 +149,48 @@ is an elegant method used to encode and decode fixed-width signed values
while efficiently preserving mathematic operations.
Most users will not need to interact with these.
_property: bignumber.fromTwos(bitwidth) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// converted from twos-compliment with //bitwidth//.
_property: BigNumber.fromTwos(bitwidth) => [[BigNumber]] @SRC<bignumber>
Returns a BigNumber with the value of //BigNumber// converted from twos-compliment with //bitwidth//.
_property: bignumber.toTwos(bitwidth) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// converted to twos-compliment with //bitwidth//.
_property: BigNumber.toTwos(bitwidth) => [[BigNumber]] @SRC<bignumber>
Returns a BigNumber with the value of //BigNumber// converted to twos-compliment with //bitwidth//.
_heading: Comparison and Equivalence
_property: bignumber.eq(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //bignumber// is equal to //otherValue//.
_property: BigNumber.eq(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //BigNumber// is equal to //otherValue//.
_property: bignumber.lt(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //bignumber// **<** //otherValue//.
_property: BigNumber.lt(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //BigNumber// **<** //otherValue//.
_property: bignumber.lte(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //bignumber// **&le;** //otherValue//.
_property: BigNumber.lte(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //BigNumber// **&le;** //otherValue//.
_property: bignumber.gt(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //bignumber// **>** //otherValue//.
_property: BigNumber.gt(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //BigNumber// **>** //otherValue//.
_property: bignumber.gte(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //bignumber// **&ge;** //otherValue//.
_property: BigNumber.gte(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //BigNumber// **&ge;** //otherValue//.
_property: bignumber.isZero() => boolean @SRC<bignumber>
Returns true if and only if the value of //bignumber// is zero.
_property: BigNumber.isZero() => boolean @SRC<bignumber>
Returns true if and only if the value of //BigNumber// is zero.
_heading: Conversion
_property: bignumber.toNumber() => number @SRC<bignumber>
Returns the value of //bignumber// as a JavaScript value.
_property: BigNumber.toNumber() => number @SRC<bignumber>
Returns the value of //BigNumber// as a JavaScript value.
This will **throw an error**
if the value is greater than or equal to //Number.MAX_SAFE_INTEGER// or less than or
equal to //Number.MIN_SAFE_INTEGER//.
_property: bignumber.toString() => string @SRC<bignumber:BigNumber.toString>
Returns the value of //bignumber// as a base-10 string.
_property: BigNumber.toString() => string @SRC<bignumber:BigNumber.toString>
Returns the value of //BigNumber// as a base-10 string.
_property: bignumber.toHexString() => string<[[datahexstring]]> @SRC<bignumber:BigNumber.toHexString>
Returns the value of //bignumber// as a base-16, ``0x``-prefixed [[datahexstring]].
_property: BigNumber.toHexString() => string<[[DataHexString]]> @SRC<bignumber:BigNumber.toHexString>
Returns the value of //BigNumber// as a base-16, ``0x``-prefixed [[DataHexString]].
_heading: Inspection
@ -215,7 +215,7 @@ _subsection: Notes
This section is a for a couple of questions that come up frequently.
_heading: Why can't I just use numbers? @<notes-safenumbers>
_heading: Why can't I just use numbers? @<BigNumber--notes-safenumbers>
The first problem many encounter when dealing with Ethereum is
the concept of numbers. Most common currencies are broken down
@ -240,10 +240,10 @@ _code: @lang<javascript>
_null:
To remedy this, all numbers (which can be large) are stored
and manipulated as [Big Numbers](bignumber).
and manipulated as [Big Numbers](BigNumber).
The functions [parseEther( etherString )](utils-parseether) and
[formatEther( wei )](utils-formatether) can be used to convert
The functions [parseEther( etherString )](utils-parseEther) and
[formatEther( wei )](utils-formatEther) can be used to convert
between string representations, which are displayed to or entered
by the user and Big Number representations which can have
mathematical operations handled safely.
@ -255,7 +255,7 @@ Everyone has their own favourite Big Number library, and once someone
has choosen one, it becomes part of their identity, like their editor,
vi vs emacs. There are over 100 Big Number libraries on [npm](link-npm-query-bignumber).
One of the biggest differences between the Ethers [[bignumber]] object and
One of the biggest differences between the Ethers [[BigNumber]] object and
other libraries is that it is immutable, which is very important when
dealing with the asynchronous nature of the blockchain.
@ -263,7 +263,7 @@ Capturing the value is not safe in async functions, so immutability
protects us from easy to make mistakes, which is not possible on the
low-level library's objects which supports myriad in-place operations.
Second, the Ethers [[bignumber]] provides all the functionality required
Second, the Ethers [[BigNumber]] provides all the functionality required
internally and should generally be sufficient for most developers while
not exposing some of the more advanced and rare functionality. So it will
be eaiser to swap out the underlying library without impacting consumers.
@ -302,6 +302,6 @@ If you, for example, used a library that used ``a.plus(b)`` instead
of ``a.add(b)``, this would break Ethers when it tries to compute
fees internally, and other libraries likely have similar logic.
But, the [[bignumber]] prototype is exposed, so you can always add a
``toMyCustomBigNumber()`` method to all [[bignumber]]'s globally
But, the [[BigNumber]] prototype is exposed, so you can always add a
``toMyCustomBigNumber()`` method to all [[BigNumber]]'s globally
which is safe.

101
docs.wrm/api/utils/bytes.wrm
View File

@ -4,7 +4,7 @@ Tra la la...
_subsection: Types
_heading: Bytes @<bytes>
_heading: Bytes @<Bytes>
A **Bytes** is any object which is an
[Array](link-js-array) or [TypedArray](link-js-typedarray) with
@ -12,39 +12,38 @@ each value in the valid byte range (i.e. between 0 and 255 inclusive),
or is an Object with a ``length`` property where each indexed property
is in the valid byte range.
_heading: BytesLike @<byteslike>
_heading: BytesLike @<BytesLike>
A **BytesLike** can be either a [[bytes]] or a [[datahexstring]].
A **BytesLike** can be either a [[Bytes]] or a [[DataHexString]].
_heading: DataHexstring @<datahexstring>
_heading: DataHexString @<DataHexString>
A **DataHexstring** is identical to a [[hexstring]] except that it has
A **DataHexstring** is identical to a [[HexString]] except that it has
an even number of nibbles, and therefore is a valid representation of
binary data as a string.
_heading: Hexstring @<hexstring>
_heading: HexString @<HexString>
A **Hexstring** is a string which has a ``0x`` prefix followed by any
number of nibbles (i.e. case-insensitive hexidecumal characters, ``0-9`` and ``a-f``).
_heading: Signature @<signature>
_heading: Signature @<Signature>
- **r** and **s** --- The x co-ordinate of **r** and the **s** value of the signature
- **v** --- The parity of the y co-ordinate of **r**
- **_vs** --- The [compact representation](link-eip-2098) of the **s** and **v**
- **recoveryParam** --- The normalized (i.e. 0 or 1) value of **v**
_heading: Flat-Format Signature @<signature-flat>
_heading: Raw Signature @<signature-raw> @inherit<string\<[[DataHexString]]\<65\>\>>
A **Flat-Format Signature** is a common Signature format where
the r, s and v are concanenated into a 65 byte (130 nibble)
[[datahexstring]].
A **Raw Signature** is a common Signature format where the r, s and v are
concanenated into a 65 byte (130 nibble) [[DataHexString]].
_heading: SignatureLike @<signaturelike>
_heading: SignatureLike @<SignatureLike>
A **SignatureLike** is similar to a [[signature]], except redundant properties
may be omitted or it may be a [[signature-flat]].
A **SignatureLike** is similar to a [[Signature]], except redundant properties
may be omitted or it may be a [[signature-raw]].
For example, if **_vs** is specified, **s** and **v** may be omitted. Likewise,
if **recoveryParam** is provided, **v** may be omitted (as in these cases the
@ -53,33 +52,31 @@ missing values can be computed).
_subsection: Inspection
_property: ethers.utils.isBytes(object) => boolean @<utils-isbytes> @SRC<bytes>
Returns true if and only if //object// is a valid [[bytes]].
_property: ethers.utils.isBytes(object) => boolean @<utils-isBytes> @SRC<bytes>
Returns true if and only if //object// is a valid [[Bytes]].
_property: ethers.utils.isBytesLike(object) => boolean @<utils-isbyteslike> @SRC<bytes>
Returns true if and only if //object// is a [[bytes]] or [[datahexstring]].
_property: ethers.utils.isBytesLike(object) => boolean @<utils-isBytesLike> @SRC<bytes>
Returns true if and only if //object// is a [[Bytes]] or [[DataHexString]].
_property: ethers.utils.isHexString(object, [ length ] ) => boolean @<utils-ishexstring> @SRC<bytes>
_property: ethers.utils.isHexString(object, [ length ] ) => boolean @<utils-isHexString> @SRC<bytes>
Returns true if and only if //object// is a valid hex string.
If //length// is specified and //object// is not a valid [[datahexstring]] of
If //length// is specified and //object// is not a valid [[DataHexString]] of
//length// bytes, an InvalidArgument error is thrown.
_subsection: Converting between Arrays and Hexstrings
_property: ethers.utils.arrayify(datahexstringOrArrayish [ , options ]) => Uint8Array @<utils-arrayify> @SRC<bytes>
Converts //datahexstringOrArrayish// to a Uint8Array.
_property: ethers.utils.arrayify(DataHexStringOrArrayish [ , options ]) => Uint8Array @<utils-arrayify> @SRC<bytes>
Converts //DataHexStringOrArrayish// to a Uint8Array.
_property: ethers.utils.hexlify(hexstringOrArrayish) => string<[[datahexstring]]> @<utils-hexlify> @SRC<bytes>
Converts //hexstringOrArrayish// to a [[datahexstring]].
_property: ethers.utils.hexlify(hexstringOrArrayish) => string<[[DataHexString]]> @<utils-hexlify> @SRC<bytes>
Converts //hexstringOrArrayish// to a [[DataHexString]].
_property: ethers.utils.hexValue(aBigNumberish) => string<[[hexstring]]> @<utils-hexvalue> @SRC<bytes>
Converts //aBigNumberish// to a [[hexstring]], with no __unnecessary__ leading
_property: ethers.utils.hexValue(aBigNumberish) => string<[[HexString]]> @<utils-hexValue> @SRC<bytes>
Converts //aBigNumberish// to a [[HexString]], with no __unnecessary__ leading
zeros.
_heading: Examples
_code: @lang<javascript>
_code: Examples @lang<javascript>
// Convert a hexstring to a Uint8Array
arrayify("0x1234")
@ -109,12 +106,12 @@ hexValue([ 1, 2 ])
_subsection: Array Manipulation
_property: ethers.utils.concat(arrayOfBytesLike) => Uint8Array @<utils-concat> @SRC<bytes>
Concatenates all the [[byteslike]] in //arrayOfBytesLike// into a single Uint8Array.
Concatenates all the [[BytesLike]] in //arrayOfBytesLike// into a single Uint8Array.
_property: ethers.utils.stripZeros(aBytesLike) => Uint8Array @<utils-stripzeros> @SRC<bytes>
_property: ethers.utils.stripZeros(aBytesLike) => Uint8Array @<utils-stripZeros> @SRC<bytes>
Returns a Uint8Array with all leading ``0`` bytes of //aBtyesLike// removed.
_property: ethers.utils.zeroPad(aBytesLike, length) => Uint8Array @<utils-zeropad> @SRC<bytes>
_property: ethers.utils.zeroPad(aBytesLike, length) => Uint8Array @<utils-zeroPad> @SRC<bytes>
Retutns a Uint8Array of the data in //aBytesLike// with ``0`` bytes prepended to
//length// bytes long.
@ -124,23 +121,23 @@ error will be thrown.
_subsection: Hexstring Manipulation
_property: ethers.utils.hexConcat(arrayOfBytesLike) => string<[[datahexstring]]> @<utils-hexconcat> @SRC<bytes>
Concatenates all the [[byteslike]] in //arrayOfBytesLike// into a single [[datahexstring]]
_property: ethers.utils.hexConcat(arrayOfBytesLike) => string<[[DataHexString]]> @<utils-hexConcat> @SRC<bytes>
Concatenates all the [[BytesLike]] in //arrayOfBytesLike// into a single [[DataHexString]]
_property: ethers.utils.hexDataLength(aBytesLike) => string<[[datahexstring]]> @<utils-hexdatalength> @SRC<bytes>
_property: ethers.utils.hexDataLength(aBytesLike) => string<[[DataHexString]]> @<utils-hexDataLength> @SRC<bytes>
Returns the length (in bytes) of //aBytesLike//.
_property: ethers.utils.hexDataSlice(aBytesLike, offset [ , endOffset ] ) => string<[[datahexstring]]> @<utils-hexdataslice> @SRC<bytes>
Returns a [[datahexstring]] representation of a slice of //aBytesLike//, from
_property: ethers.utils.hexDataSlice(aBytesLike, offset [ , endOffset ] ) => string<[[DataHexString]]> @<utils-hexDataSlice> @SRC<bytes>
Returns a [[DataHexString]] representation of a slice of //aBytesLike//, from
//offset// (in bytes) to //endOffset// (in bytes). If //endOffset// is
omitted, the length of //aBytesLike// is used.
_property: ethers.utils.hexStripZeros(aBytesLike) => string<[[hexstring]]> @<utils-hexstripzeros> @SRC<bytes>
Returns a [[hexstring]] representation of //aBytesLike// with all
_property: ethers.utils.hexStripZeros(aBytesLike) => string<[[HexString]]> @<utils-hexStripZeros> @SRC<bytes>
Returns a [[HexString]] representation of //aBytesLike// with all
leading zeros removed.
_property: ethers.utils.hexZeroPad(aBytesLike, length) => string<[[datahexstring]]> @<utils-hexzeropad> @SRC<bytes>
Returns a [[datahexstring]] representation of //aBytesLike// padded to //length// bytes.
_property: ethers.utils.hexZeroPad(aBytesLike, length) => string<[[DataHexString]]> @<utils-hexZeroPad> @SRC<bytes>
Returns a [[DataHexString]] representation of //aBytesLike// padded to //length// bytes.
If //aBytesLike// is already longer than //length// bytes long, an InvalidArgument
error will be thrown.
@ -148,20 +145,20 @@ error will be thrown.
_subsection: Signature Conversion
_property: ethers.utils.joinSignature(aSignatureLike) => string<[FlatSignature](signature-flat)> @<utils-joinsignature> @SRC<bytes>
Return the flat-format of //aSignaturelike//, which is 65 bytes (130 nibbles)
_property: ethers.utils.joinSignature(aSignatureLike) => string<[RawSignature](signature-raw)> @<utils-joinSignature> @SRC<bytes>
Return the raw-format of //aSignaturelike//, which is 65 bytes (130 nibbles)
long, concatenating the **r**, **s** and (normalized) **v** of a Signature.
_property: ethers.utils.splitSignature(aSignatureLikeOrBytesLike) => [[signature]] @<utils-splitsignature> @SRC<bytes>
Return the full expanded-format of //aSignaturelike// or a flat-format [[datahexstring]].
_property: ethers.utils.splitSignature(aSignatureLikeOrBytesLike) => [[Signature]] @<utils-splitSignature> @SRC<bytes>
Return the full expanded-format of //aSignaturelike// or a raw-format [[DataHexString]].
Any missing properties will be computed.
_subsection: Random Bytes
_property: ethers.utils.randomBytes(length) => Uint8Array @<utils-randombytes> @SRC<random/index>
_property: ethers.utils.randomBytes(length) => Uint8Array @<utils-randomBytes> @SRC<random/index>
Return a new Uint8Array of //length// random bytes.
_property: ethers.utils.shuffled(array) => Array<any> @<utils.shuffled> @SRC<random>
_property: ethers.utils.shuffled(array) => Array<any> @<utils-shuffled> @SRC<random>
Return a copy of //array// shuffled using [[link-wiki-shuffle]].
_code: Examples @lang<javascript>
@ -169,10 +166,12 @@ _code: Examples @lang<javascript>
utils.randomBytes(8)
//!
const foo = [ 1, 2, 3, 4, 5, 6, 7 ];
utils.shuffled(foo);
const data = [ 1, 2, 3, 4, 5, 6, 7 ];
// Returns a new Array
utils.shuffled(data);
//!
// The original array is unscathed...
foo
// The Original is unscathed...
data
//!

18
docs.wrm/api/utils/constants.wrm
View File

@ -12,38 +12,38 @@ const { constants } = require("@ethersproject/constants");
_subsection: Bytes
_property: ethers.constants.AddressZero => string<[Address](address)> @<constants-addresszero> @SRC<constants>
_property: ethers.constants.AddressZero => string<[Address](address)> @<constants-AddressZero> @SRC<constants>
The Address Zero, which is 20 bytes (40 nibbles) of zero.
_property: ethers.constants.HashZero => string<[[datahexstring]]<32>> @<constants-hashzero> @SRC<constants>
_property: ethers.constants.HashZero => string<[[DataHexString]]<32>> @<constants-HashZero> @SRC<constants>
The Hash Zero, which is 32 bytes (64 nibbles) of zero.
_subsection: Strings
_property: ethers.constants.EtherSymbol => string @<constants-ethersymbol> @SRC<constants>
_property: ethers.constants.EtherSymbol => string @<constants-EtherSymbol> @SRC<constants>
The Ether symbol, **&Xi;**.
_subsection: BigNumber
_property: ethers.constants.NegativeOne => [[bignumber]] @<constants-negativeone> @SRC<constants>
_property: ethers.constants.NegativeOne => [[BigNumber]] @<constants-NegativeOne> @SRC<constants>
The BigNumber value representing ``"-1"``.
_property: ethers.constants.Zero => [[bignumber]] @<constants-zero> @SRC<constants>
_property: ethers.constants.Zero => [[BigNumber]] @<constants-Zero> @SRC<constants>
The BigNumber value representing ``"0"``.
_property: ethers.constants.One => [[bignumber]] @<constants-one> @SRC<constants>
_property: ethers.constants.One => [[BigNumber]] @<constants-One> @SRC<constants>
The BigNumber value representing ``"1"``.
_property: ethers.constants.Two => [[bignumber]] @<constants-two> @SRC<constants>
_property: ethers.constants.Two => [[BigNumber]] @<constants-Two> @SRC<constants>
The BigNumber value representing ``"2"``.
_property: ethers.constants.WeiPerEther => [[bignumber]] @<constants-weiperether> @SRC<constants>
_property: ethers.constants.WeiPerEther => [[BigNumber]] @<constants-WeiPerEther> @SRC<constants>
The BigNumber value representing ``"1000000000000000000"``, which is the
number of Wei per Ether.
_property: ethers.constants.MaxUint256 => [[bignumber]] @<constants-maxuint256> @SRC<constants>
_property: ethers.constants.MaxUint256 => [[BigNumber]] @<constants-MaxUint256> @SRC<constants>
The BigNumber value representing the maximum ``uint256`` value.

14
docs.wrm/api/utils/display-logic.wrm
View File

@ -10,10 +10,10 @@ gas prices in gwei for the User Interface, but when sending
a transaction, both must be specified in wei.
The [parseUnits](unit-conversion) will parse a string representing
ether, such as ``1.1`` into a [BigNumber](bignumber) in wei, and is
ether, such as ``1.1`` into a [BigNumber](BigNumber) in wei, and is
useful when a user types in a value, such as sending 1.1 ether.
The [formatUnits](unit-conversion) will format a [BigNumberish](bignumberish)
The [formatUnits](unit-conversion) will format a [BigNumberish](BigNumberish)
into a string, which is useful when displaying a balance.
@ -56,17 +56,17 @@ Returns a string with value grouped by 3 digits, separated by ``,``.
_heading: Conversion @<unit-conversion>
_property: ethers.utils.formatUnits(value [ , unit = "ether" ] ) => string @<utils-formatunits> @SRC<units>
_property: ethers.utils.formatUnits(value [ , unit = "ether" ] ) => string @<utils-formatUnits> @SRC<units>
Returns a string representation of //value// formatted with //unit//
digits (if it is a number) or to the unit specified (if a string).
_property: ethers.utils.formatEther(value) => string @<utils-formatether> @SRC<units>
_property: ethers.utils.formatEther(value) => string @<utils-formatEther> @SRC<units>
The equivalent to calling ``formatUnits(value, "ether")``.
_property: ethers.utils.parseUnits(value [ , unit = "ether" ] ) => [BigNumber](bignumber) @<utils-parseunits> @SRC<units>
Returns a [BigNumber](bignumber) representation of //value//, parsed with
_property: ethers.utils.parseUnits(value [ , unit = "ether" ] ) => [BigNumber](BigNumber) @<utils-parseUnits> @SRC<units>
Returns a [BigNumber](BigNumber) representation of //value//, parsed with
//unit// digits (if it is a number) or from the unit specified (if
a string).
_property: ethers.utils.parseEther(value) => [BigNumber](bignumber) @<utils-parseether> @SRC<units>
_property: ethers.utils.parseEther(value) => [BigNumber](BigNumber) @<utils-parseEther> @SRC<units>
The equivalent to calling ``parseUnits(value, "ether")``.

16
docs.wrm/api/utils/encoding.wrm
View File

@ -1,6 +1,6 @@
_section: Encoding Utilities @<encoding>
_subsection: Base58 @<bse58> @SRC<basex:Base58>
_subsection: Base58 @<Bse58> @SRC<basex:Base58>
_property: ethers.utils.base58.decode(textData) => Uin8Array
Return a typed Uint8Array representation of //textData// decoded using
@ -10,7 +10,7 @@ _property: ethers.utils.base58.encode(aBytesLike) => string
Return //aBytesLike// encoded as a string using the base-58 encoding.
_subsection: Base64 @<base64>
_subsection: Base64 @<Base64>
_property: ethers.utils.base64.decode(textData) => Uin8Array @SRC<base64>
Return a typed Uint8Array representation of //textData// decoded using
@ -20,22 +20,22 @@ _property: ethers.utils.base64.encode(aBytesLike) => string @SRC<base64>
Return //aBytesLike// encoded as a string using the base-64 encoding.
_subsection: Recursive-Length Prefix @<rlp>
_subsection: Recursive-Length Prefix @<rlp--methods>
The [[link-rlp]] encoding is used throughout Ethereum to serialize nested
structures of Arrays and data.
_property: ethers.utils.RLP.encode(dataObject) => string<[[datahexstring]]> @<rlp-encode> @SRC<rlp>
_property: ethers.utils.RLP.encode(dataObject) => string<[[DataHexString]]> @<utils-rlpEncode> @SRC<rlp>
Encode a structured Data Object into its RLP-encoded representation.
Each Data component may be an valid [[byteslike]].
Each Data component may be an valid [[BytesLike]].
_property: ethers.utils.RLP.decode(aBytesLike) => [DataObject](rlp-dataobject) @<rlp-decode> @SRC<rlp>
_property: ethers.utils.RLP.decode(aBytesLike) => [DataObject](rlp--dataobject) @<utils.rlpDecode> @SRC<rlp>
Decode an RLP-encoded //aBytesLike// into its structured Data Object.
All Data components will be returned as a [[datahexstring]].
All Data components will be returned as a [[DataHexString]].
_heading: Data Object @<rlp-dataobject>
_heading: Data Object @<rlp--dataobject>
A **Data Object** is a recursive structure which is used to serialize many
internal structures in Ethereum. Each **Data Object** can either be:

44
docs.wrm/api/utils/fixednumber.wrm
View File

@ -1,4 +1,4 @@
_section: FixedNumber @<fixednumber>
_section: FixedNumber @<FixedNumber>
A **FixedNumber** is a fixed-width (in bits) number with an internal
base-10 divisor, which allows it to represent a decimal fractional
@ -9,53 +9,53 @@ _subsection: Creating Instances
The FixedNumber constructor cannot be called directly. There are several
static methods for creating a FixedNumber.
_property: FixedNumber.from(value [ , format = "fixed" ] ) => [[fixednumber]] @SRC<bignumber:FixedNumber.from>
_property: FixedNumber.from(value [ , format = "fixed" ] ) => [[FixedNumber]] @SRC<bignumber:FixedNumber.from>
Returns an instance of a **FixedNumber** for //value// as a //format//.
_property: FixedNumber.fromBytes(aBytesLike [ , format = "fixed" ] ) => [[fixednumber]] @SRC<bignumber>
_property: FixedNumber.fromBytes(aBytesLike [ , format = "fixed" ] ) => [[FixedNumber]] @SRC<bignumber>
Returns an instance of a **FixedNumber** for //value// as a //format//.
_property: FixedNumber.fromString(value [ , format = "fixed" ] ) => [[fixednumber]] @SRC<bignumber:FixedNumber.fromString>
_property: FixedNumber.fromString(value [ , format = "fixed" ] ) => [[FixedNumber]] @SRC<bignumber:FixedNumber.fromString>
Returns an instance of a **FixedNumber** for //value// as a //format//. The //value// must
not contain more decimals than the //format// permits.
_property: FixedNumber.fromValue(value [ , decimals = 0 [ , format = "fixed" ] ] ) => [[fixednumber]] @SRC<bignumber:FixedNumber.fromValue>
_property: FixedNumber.fromValue(value [ , decimals = 0 [ , format = "fixed" ] ] ) => [[FixedNumber]] @SRC<bignumber:FixedNumber.fromValue>
Returns an instance of a **FixedNumber** for //value// with //decimals// as a //format//.
_subsection: Properties
_property: fixednumber.format
The [FixedFormat](fixedformat) of //fixednumber//.
The [FixedFormat](FixedFormat) of //fixednumber//.
_subsection: Methods
_heading: Math Operations
_property: fixednumber.addUnsafe(otherValue) => [[fixednumber]] @SRC<bignumber/fixednumber>
_property: fixednumber.addUnsafe(otherValue) => [[FixedNumber]] @SRC<bignumber/fixednumber>
Returns a new FixedNumber with the value of //fixedvalue// **+** //otherValue//.
_property: fixednumber.subUnsafe(otherValue) => [[fixednumber]] @SRC<bignumber/fixednumber>
Returns a new FixedNumber with the value of //fixedvalue// **&ndash;** //otherValue//.
_property: fixednumber.subUnsafe(otherValue) => [[FixedNumber]] @SRC<bignumber/fixednumber>
Returns a new FixedNumber with the value of //fixedvalue// **-** //otherValue//.
_property: fixednumber.mulUnsafe(otherValue) => [[fixednumber]] @SRC<bignumber/fixednumber>
_property: fixednumber.mulUnsafe(otherValue) => [[FixedNumber]] @SRC<bignumber/fixednumber>
Returns a new FixedNumber with the value of //fixedvalue// **&times;** //otherValue//.
_property: fixednumber.divUnsafe(otherValue) => [[fixednumber]] @SRC<bignumber/fixednumber>
Returns a new FixedNumber with the value of //fixedvalue// **&#247;** //otherValue//.
_property: fixednumber.divUnsafe(otherValue) => [[FixedNumber]] @SRC<bignumber/fixednumber>
Returns a new FixedNumber with the value of //fixedvalue// **&div;** //otherValue//.
_property: fixednumber.round([ decimals = 0 ]) => [[fixednumber]] @SRC<bignumber/fixednumber>
_property: fixednumber.round([ decimals = 0 ]) => [[FixedNumber]] @SRC<bignumber/fixednumber>
Returns a new FixedNumber with the value of //fixedvalue// rounded to //decimals//.
_heading: Conversion
_property: fixednumber.toFormat(format) => [[fixednumber]] @SRC<bignumber/fixednumber>
_property: fixednumber.toFormat(format) => [[FixedNumber]] @SRC<bignumber/fixednumber>
Returns a new FixedNumber with the value of //fixedvalue// with //format//.
_property: fixednumber.toHexString() => string @SRC<bignumber/fixednumber>
Returns a [Hexstring](hexstring) representation of //fixednumber//.
Returns a [[HexString]] representation of //fixednumber//.
_property: fixednumber.toString() => string @SRC<bignumber/fixednumber>
Returns a string representation of //fixednumber//.
@ -71,14 +71,14 @@ _property: FixedNumber.isFixedNumber(value) => boolean @SRC<bignumber/fixednumb
Returns true if and only if //value// is a **FixedNumber**.
_subsection: FixedFormat @<fixedformat>
_subsection: FixedFormat @<FixedFormat>
A **FixedFormat** is a simple object which represents a decimal
(base-10) Fixed-Point data representation. Usually using this
class directly is uneccessary, as passing in a [[fixedformatstring]]
directly into the [[fixednumber]] will automatically create this.
class directly is uneccessary, as passing in a [[FixedFormat--strings]]
directly into the [[FixedNumber]] will automatically create this.
_heading: Format Strings @<fixedformatstring>
_heading: Format Strings @<FixedFormat--strings>
A format string is composed of three components, including signed-ness,
bit-width and number of decimals.
@ -100,11 +100,11 @@ For example:
_heading: Creating Instances
_property: FixedFormat.from(value = "fixed128x18") => [[fixedformat]] @<fixednumber-from> @SRC<bignumber/fixednumber:FixedFormat.from>
_property: FixedFormat.from(value = "fixed128x18") => [[FixedFormat]] @<FixedNumber-from> @SRC<bignumber/fixednumber:FixedFormat.from>
Returns a new instance of a **FixedFormat** defined by //value//. Any valid [[fixedformatstring]]
Returns a new instance of a **FixedFormat** defined by //value//. Any valid [[FixedFormat--strings]]
may be passed in as well as any object which has any of ``signed``, ``width`` and ``decimals``
defined, including a [[fixedformat]] object.
defined, including a [[FixedFormat]] object.
_heading: Properties

168
docs.wrm/api/utils/hashing.wrm
View File

@ -3,29 +3,113 @@ _section: Hashing Algorithms
Explain what hash functions are?
_subsection: Cryptographic Hashing
_subsection: Cryptographic Hash Functions
The [Cryptographic Hash Functions](link-wiki-cryptographichash)
are a specific family of hash functions.
_property: ethers.utils.keccak256(aBytesLike) => string<[[datahexstring]]<32>> @<utils-keccak256> @SRC<keccak256>
_property: ethers.utils.id(text) => string<[[DataHexString]]<32>> @<utils-id> @SRC<hash>
The Ethereum Identity function computs the [KECCAK256](link-wiki-sha3) hash of the //text// bytes.
_property: ethers.utils.keccak256(aBytesLike) => string<[[DataHexString]]<32>> @<utils-keccak256> @SRC<keccak256>
Returns the [KECCAK256](link-wiki-sha3) digest //aBytesLike//.
_property: ethers.utils.ripemd160(aBytesLike) => string<[[datahexstring]]<20>> @<utils-ripemd160> @SRC<sha2>
_property: ethers.utils.ripemd160(aBytesLike) => string<[[DataHexString]]<20>> @<utils-ripemd160> @SRC<sha2>
Returns the [RIPEMD-160](link-wiki-ripemd) digest of //aBytesLike//.
_property: ethers.utils.sha256(aBytesLike) => string<[[datahexstring]]<32>> @<utils-sha256> @SRC<sha2:function.sha256>
_property: ethers.utils.sha256(aBytesLike) => string<[[DataHexString]]<32>> @<utils-sha256> @SRC<sha2:function.sha256>
Returns the [SHA2-256](link-wiki-sha2) digest of //aBytesLike//.
_property: ethers.utils.sha512(aBytesLike) => string<[[datahexstring]]<64>> @<utils-sha512> @SRC<sha2:function.sha512>
_property: ethers.utils.sha512(aBytesLike) => string<[[DataHexString]]<64>> @<utils-sha512> @SRC<sha2:function.sha512>
Returns the [SHA2-512](link-wiki-sha2) digest of //aBytesLike//.
_property: ethers.utils.computeHmac(algorithm, key, data) => string<[[datahexstring]]> @<utils-computehmac> @SRC<sha2>
_code: KECCAK256 @lang<javascript>
utils.keccak256([ 0x12, 0x34 ])
//!
utils.keccak256("0x")
//!
utils.keccak256("0x1234")
//!
// The value MUST be data, such as:
// - an Array of numbers
// - a data hex string (e.g. "0x1234")
// - a Uint8Array
// Do NOT use UTF-8 strings that are not a DataHexstring
utils.keccak256("hello world")
//! error
// If needed, convert strings to bytes first:
utils.keccak256(utils.toUtf8Bytes("hello world"))
//!
// Or equivalently use the identity function:
utils.id("hello world")
//!
// Keep in mind that the string "0x1234" represents TWO
// bytes (i.e. [ 0x12, 0x34 ]. If you wish to compute the
// hash of the 6 characters "0x1234", convert it to UTF-8
// bytes first using utils.toUtf8Bytes.
// Consider the following examples:
// Hash of TWO (2) bytes:
utils.keccak256("0x1234")
//!
// Hash of TWO (2) bytes: (same result)
utils.keccak256([ 0x12, 0x34 ])
//!
const bytes = utils.toUtf8Bytes("0x1234");
// <hide>
bytes
// </hide>
//!
// Hash of SIX (6) characters (different than above)
utils.keccak256(bytes)
//!
// Hash of SIX (6) characters (same result)
utils.id("0x1234")
//!
_code: RIPEMD160 @lang<javascript>
utils.ripemd160("0x")
//!
utils.ripemd160("0x1234")
//!
_code: SHA-2 @lang<javascript>
utils.sha256("0x")
//!
utils.sha256("0x1234")
//!
utils.sha512("0x")
//!
utils.sha512("0x1234")
//!
_subsection: HMAC @<utils--hmac>
_property: ethers.utils.computeHmac(algorithm, key, data) => string<[[DataHexString]]> @<utils-computeHmac> @SRC<sha2>
Returns the [HMAC](link-wiki-hmac) of //data// with //key//
using the [Algorithm](supported-algorithm) //algorithm//.
using the [Algorithm](utils--hmac-supported-algorithm) //algorithm//.
_heading: HMAC Supported Algorithms @<supported-algorithm> @SRC<sha2:enum.SupportedAlgorithm>
_heading: **HMAC Supported Algorithms** @<utils--hmac-supported-algorithm> @SRC<sha2:enum.SupportedAlgorithm>
_property: ethers.utils.SupportedAlgorithm.sha256 => string
Use the [SHA2-256](link-wiki-sha2) hash algorithm.
@ -33,20 +117,43 @@ Use the [SHA2-256](link-wiki-sha2) hash algorithm.
_property: ethers.utils.SupportedAlgorithm.sha512 => string
Use the [SHA2-512](link-wiki-sha2) hash algorithm.
_code: HMAC @lang<javascript>
_subsection: Common Hashing Helpers
const key = "0x0102";
const data = "0x1234";
utils.computeHmac("sha256", key, data)
//!
_property: ethers.utils.hashMessage(message) => string<[[datahexstring]]<32>> @<utils-hashmessage> @SRC<hash>
_subsection: Hashing Helpers
_property: ethers.utils.hashMessage(message) => string<[[DataHexString]]<32>> @<utils-hashMessage> @SRC<hash>
Computes the [[link-eip-191]] personal message digest of //message//. Personal messages are
converted to UTF-8 bytes and prefixed with ``\\x19Ethereum Signed Message:``
and the length of //message//.
_property: ethers.utils.id(text) => string<[[datahexstring]]<32>> @<utils-id> @SRC<hash>
The Ethereum Identity function computs the [KECCAK256](link-wiki-sha3) hash of the //text// bytes.
_property: ethers.utils.namehash(name) => string<[[datahexstring]]<32>> @<utils-namehash> @SRC<hash>
_property: ethers.utils.namehash(name) => string<[[DataHexString]]<32>> @<utils-namehash> @SRC<hash>
Returns the [ENS Namehash](link-namehash) of //name//.
_code: Hashing Messages @lang<javascript>
// @TODO: include exampels of hashMessage; it can be complex. :)
_code: Namehash @lang<javascript>
utils.namehash("")
//!
utils.namehash("eth")
//!
utils.namehash("ricmoo.firefly.eth")
//!
utils.namehash("ricmoo.xyz")
//!
_subsection: Solidity Hashing Algorithms
@ -54,16 +161,29 @@ When using the Solidity ``abi.packEncoded(...)`` function, a non-standard
//tightly packed// version of encoding is used. These functions implement
the tightly packing algorithm.
_property: ethers.utils.solidityPack(arrayOfTypes, arrayOfValues) => string<[[datahexstring]]> @<utils-soliditypack> @SRC<solidity:pack>
Returns the non-standard encoded //arrayOfValues// packed according to
their respecive type in //arrayOfTypes//.
_property: ethers.utils.solidityPack(types, values) => string<[[DataHexString]]> @<utils-solidityPack> @SRC<solidity:pack>
Returns the non-standard encoded //values// packed according to
their respecive type in //types//.
_property: ethers.utils.solidityKeccak256(arrayOfTypes, arrayOfValues) => string<[[datahexstring]]<32>> @<utils-soliditykeccak256> @SRC<solidity:keccak256>
Returns the [KECCAK256](link-wiki-sha3) of the non-standard encoded //arrayOfValues// packed
according to their respective type in //arrayOfTypes//.
_property: ethers.utils.solidityKeccak256(types, values) => string<[[DataHexString]]<32>> @<utils-solidityKeccak256> @SRC<solidity:keccak256>
Returns the [KECCAK256](link-wiki-sha3) of the non-standard encoded //values// packed
according to their respective type in //types//.
_property: ethers.utils.soliditySha256(arrayOfTypes, arrayOfValues) => string<[[datahexstring]]<32>> @<utils-soliditysha256> @SRC<solidity:sha256>
Returns the [SHA2-256](link-wiki-sha2) of the non-standard encoded //arrayOfValues// packed
according to their respective type in //arrayOfTypes//.
_property: ethers.utils.soliditySha256(types, values) => string<[[DataHexString]]<32>> @<utils-soliditySha256> @SRC<solidity:sha256>
Returns the [SHA2-256](link-wiki-sha2) of the non-standard encoded //values// packed
according to their respective type in //types//.
_code: Solidity Hashing @lang<javascript>
utils.solidityPack([ "int16", "uint48" ], [ -1, 12 ])
//!
utils.solidityPack([ "string", "uint8" ], [ "Hello", 3 ])
//!
utils.solidityKeccak256([ "int16", "uint48" ], [ -1, 12 ])
//!
utils.soliditySha256([ "int16", "uint48" ], [ -1, 12 ])
//!

52
docs.wrm/api/utils/hdnode.wrm
View File

@ -1,16 +1,16 @@
_section: HD Wallet
_section: HD Wallet @<hdnodes>
TODO: Explain [BIP32](link-bip-32) [BIP-39](link-bip-39) and whatnot here...
_subsection: Types
_heading: Constants @<hdnode-defaultpath> @SRC<hdnode:defaultPath>
_heading: Constants @<hdnodes--defaultpath> @SRC<hdnode:defaultPath>
_property: ethers.utils.defaultPath => "m/44'/60'/0'/0/0"
The default path for Ethereum in an HD Wallet
_heading: Mnemonic @<hdnode-mnemonic>
_heading: Mnemonic @<Mnemonic>
_property: mnemonic.phrase => string
The mnemonic phrase for this mnemonic. It is 12, 15, 18, 21 or 24 words long
@ -23,39 +23,39 @@ _property: mnemonic.locale => string
The language of the wordlist this mnemonic is using.
_subsection: HDNode @<hdnode> @SRC<hdnode:class.HDNode>
_subsection: HDNode @<HDNode> @SRC<hdnode:class.HDNode>
_heading: Creating Instances
_heading: Creating Instances @<HDNode--creating>
_property: ethers.HDNode.fromMnemonic(phrase [, password [, wordlist ] ]) => [[hdnode]] @SRC<hdnode>
Return the [[hdnode]] for //phrase// with the optional //password//
_property: ethers.HDNode.fromMnemonic(phrase [, password [, wordlist ] ]) => [[HDNode]] @<HDNode-fromMnemonic> @SRC<hdnode>
Return the [[HDNode]] for //phrase// with the optional //password//
and //wordlist//.
_property: ethers.HDNode.fromSeed(aBytesLike) => [[hdnode]] @SRC<hdnode>
Return the [[hdnode]] for the seed //aBytesLike//.
_property: ethers.HDNode.fromSeed(aBytesLike) => [[HDNode]] @<HDNode-fromSeed> @SRC<hdnode>
Return the [[HDNode]] for the seed //aBytesLike//.
_property: ethers.HDNode.fromExtendedKey(extendedKey) => [[hdnode]] @SRC<hdnode>
Return the [[hdnode]] for the //extendedKey//. If //extendedKey// was
_property: ethers.HDNode.fromExtendedKey(extendedKey) => [[HDNode]] @<HDNode-fromExtendedKey> @SRC<hdnode>
Return the [[HDNode]] for the //extendedKey//. If //extendedKey// was
neutered, the **HDNode** will only be able to compute addresses and not
private keys.
_heading: Properties
_heading: Properties @<HDNode--properties>
_property: hdNode.privateKey => string<[[datahexstring]]<32>>
_property: hdNode.privateKey => string<[[DataHexString]]<32>>
The private key for this HDNode.
_property: hdNode.publicKey => string<[[datahexstring]]<33>>
_property: hdNode.publicKey => string<[[DataHexString]]<33>>
The (compresses) public key for this HDNode.
_property: hdNode.fingerprint => string<[[datahexstring]]<4>>
_property: hdNode.fingerprint => string<[[DataHexString]]<4>>
The fingerprint is meant as an index to quickly match parent and
children nodes together, however collisions may occur and software
should verify matching nodes.
Most developers will not need to use this.
_property: hdNode.parentFingerprint => string<[[datahexstring]]<4>>
_property: hdNode.parentFingerprint => string<[[DataHexString]]<4>>
The fingerprint of the parent node. See //fingerprint// for more
details.
@ -64,14 +64,14 @@ Most developers will not need to use this.
_property: hdNode.address => string<[[address]]>
The address of this HDNode.
_property: hdNode.mnemonic => [[hdnode-mnemonic]]
_property: hdNode.mnemonic => [[Mnemonic]]
The mnemonic of this HDNode, if known.
_property: hdNode.path => string
The path of this HDNode, if known. If the //mnemonic// is also known,
this will match ``mnemonic.path``.
_property: hdNode.chainCode => string<[[datahexstring]]<32>>
_property: hdNode.chainCode => string<[[DataHexString]]<32>>
The chain code is used as a non-secret private key which is then used
with EC-multiply to provide the ability to derive addresses without
the private key of child non-hardened nodes.
@ -97,29 +97,29 @@ serializing and deserializing (using the ``fromExtendedKey`` class
method) will result in reduced information.
_heading: Methods
_heading: Methods @<HDNode--methods>
_property: hdNode.neuter() => [[hdnode]] @SRC<hdnode>
_property: hdNode.neuter() => [[HDNode]] @<HDNode-neuter> @SRC<hdnode>
Return a new instance of //hdNode// with its private key removed
but all otehr properties preserved. This ensures that the key
can not leak the private key of itself or any derived children,
but may still be used to compute the addresses of itself and
any non-hardened children.
_property: hdNode.derivePath(path) => [[hdnode]] @SRC<hdnode>
Return a new [[hdnode]] which is the child of //hdNode// found
_property: hdNode.derivePath(path) => [[HDNode]] @<HDNode-derivePath> @SRC<hdnode>
Return a new [[HDNode]] which is the child of //hdNode// found
by deriving //path//.
_subsection: Other Functions
_subsection: Other Functions @<HDNode--utilities>
_property: ethers.utils.mnemonicToSeed(phrase [ , password]) => string<[[datahexstring]]<64>> @SRC<hdnode>
_property: ethers.utils.mnemonicToSeed(phrase [ , password]) => string<[[DataHexString]]<64>> @<utils-mnemonicToSeed> @SRC<hdnode>
Convert a mnemonic phrase to a seed, according to [BIP-39](link-bip-39).
_property: ethers.utils.mnemonicToEntropy(phrase [ , wordlist ]) => string<[[datahexstring]]> @SRC<hdnode>
_property: ethers.utils.mnemonicToEntropy(phrase [ , wordlist ]) => string<[[DataHexString]]> @<utils-mnemonicToEntropy> @SRC<hdnode>
Convert a mnemonic phrase to its entropy, according to [BIP-39](link-bip-39).
_property: ethers.utils.isValidMnemonic(phrase [ , wordlist ]) => boolean @SRC<hdnode>
_property: ethers.utils.isValidMnemonic(phrase [ , wordlist ]) => boolean @<utils-isValidMnemonic> @SRC<hdnode>
Returns true if //phrase// is a valid mnemonic phrase, by
testing the checksum.

44
docs.wrm/api/utils/logger.wrm
View File

@ -3,21 +3,21 @@ _section: Logging @<logging>
These are just a few simple logging utilities provided to simplify
and standardize the error facilities across the Ethers library.
The [[logger]] library has zero dependencies and is intentionally
The [[Logger]] library has zero dependencies and is intentionally
very light so it can be easily included in each library.
The [Censorship](logger-censorship) functionality relies on one instance
The [Censorship](Logger--censorship) functionality relies on one instance
of the Ethers library being included. In large bundled packages or when
``npm link`` is used, this may not be the case. If you require this
functionality, ensure that your bundling is configured properly.
_subsection: Logger @<logger> @SRC<logger:class.Logger>
_subsection: Logger @<Logger> @SRC<logger:class.Logger>
_property: new ethers.utils.Logger(version) @SRC<logger:constructor.Logger>
Create a new logger which will include //version// in all errors thrown.
_property: Logger.globalLogger() => [[logger]] @SRC<logger>
_property: Logger.globalLogger() => [[Logger]] @SRC<logger>
Returns the singleton global logger.
@ -35,7 +35,7 @@ Log warnings.
_heading: Errors
These functions honor the current [Censorship](logger-censorship) and help create
These functions honor the current [Censorship](Logger--censorship) and help create
a standard error model for detecting and processing errors within Ethers.
_property: logger.makeError(message [ , code = UNKNOWN_ERROR [ , params ] ]) => Error @SRC<logger>
@ -48,7 +48,7 @@ Throw an Error with //message// and an optional //code// and
additional //params// set.
_property: logger.throwArgumentError(message, name, value) => never @SRC<logger>
Throw an [INVALID_ARGUMENT](error-invalidargument) Error with //name// and //value//.
Throw an [INVALID_ARGUMENT](errors-InvalidArgument) Error with //name// and //value//.
_heading: Usage Validation
@ -61,24 +61,24 @@ as ``checkNew``. This is useful for ensuring abstract classes are not
being instantiated.
_property: logger.checkArgumentCount(count, expectedCound [ , message) => void @SRC<logger>
If //count// is not equal to //expectedCount//, throws a [MISSING_ARGUMENT](error-missingargument)
or [UNEXPECTED_ARGUMENT](error-unexpectedargument) error.
If //count// is not equal to //expectedCount//, throws a [MISSING_ARGUMENT](errors-MissingArgument)
or [UNEXPECTED_ARGUMENT](errors-UnexpectedArgument) error.
_property: logger.checkNew(target, kind) => void @SRC<logger>
If //target// is not a valid ``this`` or ``target`` value, throw a
[MISSING_NEW](error-missingnew) error. This is useful to ensure
[MISSING_NEW](errors-MissingNew) error. This is useful to ensure
callers of a Class are using ``new``.
_property: logger.checkNormalize(message) => void @SRC<logger>
Check that the environment has a correctly functioning [[link-js-normalize]]. If not, a
[UNSUPPORTED_OPERATION](error-unsupported) error is thrown.
[UNSUPPORTED_OPERATION](errors-UnsupportedOperation) error is thrown.
_property: logger.checkSafeUint53(value [, message ]) => void @SRC<logger>
If //value// is not safe as a [JavaScript number](link-wiki-ieee754), throws a
[NUMERIC_FAULT](error-numericfault) error.
[NUMERIC_FAULT](errors-NumericFault) error.
_heading: Censorship @<logger-censorship>
_heading: Censorship @<Logger--censorship>
_property: Logger.setCensorship(censor [ , permanent = false ]) => void @SRC<logger>
Set error censorship, optionally preventing errors from being uncensored.
@ -89,7 +89,7 @@ by masking the message and values of errors.
This can impact debugging, making it substantially more difficult.
_property: Logger.setLogLevel(logLevel) => void @SRC<logger>
Set the log level, to suppress logging output below a [particular log level](logger-levels).
Set the log level, to suppress logging output below a [particular log level](Logger-levels).
_subsection: Errors @<errors>
@ -106,13 +106,13 @@ The operation is not implemented.
_property: Logger.errors.SERVER_ERROR
There was an error communicating with a server.
_property: Logger.errors.TIMEOUT @<error-timeout>
_property: Logger.errors.TIMEOUT @<errors-Timeout>
A timeout occurred.
_property: Logger.errors.UNKNOWN_ERROR @<error-unknown>
_property: Logger.errors.UNKNOWN_ERROR @<errors-UnknownError>
A generic unknown error.
_property: Logger.errors.UNSUPPORTED_OPERATION @<error-unsupported>
_property: Logger.errors.UNSUPPORTED_OPERATION @<errors-UnsupportedOperation>
The operation is not supported.
@ -122,7 +122,7 @@ _property: Logger.errors.BUFFER_OVERRUN
The amount of data needed is more than the amount of data required,
which would cause the data buffer to read past its end.
_property: Logger.errors.NUMERIC_FAULT @<error-numericfault>
_property: Logger.errors.NUMERIC_FAULT @<errors-NumericFault>
There was an invalid operation done on numeric values.
Common cases of this occur when there is [[link-wiki-overflow]],
@ -131,19 +131,19 @@ Common cases of this occur when there is [[link-wiki-overflow]],
_heading: Usage Error Codes
_property: Logger.errors.INVALID_ARGUMENT @<error-invalidargument>
_property: Logger.errors.INVALID_ARGUMENT @<errors-InvalidArgument>
The type or value of an argument is invalid. This will generally also
include the ``name`` and ``value`` of the argument. Any function which
accepts sensitive data (such as a private key) will include the string
``[\[REDACTED]\]`` instead of the value passed in.
_property: Logger.errors.MISSING_ARGUMENT @<error-missingargument>
_property: Logger.errors.MISSING_ARGUMENT @<errors-MissingArgument>
An expected parameter was not specified.
_property: Logger.errors.MISSING_NEW @<error-missingnew>
_property: Logger.errors.MISSING_NEW @<errors-MissingNew>
An object is a Class, but is now being called with ``new``.
_property: Logger.errors.UNEXPECTED_ARGUMENT @<error-unexpectedargument>
_property: Logger.errors.UNEXPECTED_ARGUMENT @<errors-UnexpectedArgument>
Too many parameters we passed into a function.
@ -190,7 +190,7 @@ This error can also indicate that the transaction is expected to fail regardless
if for example an account with no tokens is attempting to send a token.
_subsection: Log Levels @<logger-levels>
_subsection: Log Levels @<Logger-levels>
_property: Logger.levels.DEBUG
Log all output, including debugging information.

22
docs.wrm/api/utils/signing-key.wrm
View File

@ -1,23 +1,23 @@
_section: Signing Key @<utils-signingkey>
_section: Signing Key @<SigningKey>
_property: new ethers.utils.SigningKey(privateKey)
_property: new ethers.utils.SigningKey(privateKey) @<SigningKey-constructor> @src<signing-key:constructor.SigningKey>
Create a new SigningKey for //privateKey//.
_property: signingKey.privateKey => string<[[datahexstring]]<32>>
_property: signingKey.privateKey => string<[[DataHexString]]<32>>
The private key for this Signing Key.
_property: signingKey.publicKey => string<[[datahexstring]]<65>>
_property: signingKey.publicKey => string<[[DataHexString]]<65>>
The uncompressed public key for this Signing Key. It will always be
65 bytes (130 nibbles) and begine with ``0x04``.
_property: signingKey.compressedPublicKey => string<[[datahexstring]]<33>>
_property: signingKey.compressedPublicKey => string<[[DataHexString]]<33>>
The compressed public key for this Signing Key. It will always be
33 bytes (66 nibbles) and begine with either ``0x02`` or ``0x03``.
_property: signingKey.signDigest(digest) => [[signature]]
_property: signingKey.signDigest(digest) => [[Signature]]
Sign the //digest// and return the signature.
_property: signingKey.computeSharedSecret(otherKey) => string<[[datahexstring]]<32>>
_property: signingKey.computeSharedSecret(otherKey) => string<[[DataHexString]]<32>> @SRC<signing-key>
Compute the ECDH shared secret with //otherKey//. The //otherKey// may be
either a public key or a private key, but generally will be a public key from
another party.
@ -25,13 +25,13 @@ another party.
It is best practice that each party computes the hash of this before using it
as a symmetric key.
_property: SigningKey.isSigningKey(anObject) => boolean
_property: SigningKey.isSigningKey(anObject) => boolean @SRC<signing-key>
Returns true if //anObject// is a SigningKey.
_subsection: Other Functions
_property: ethers.utils.verifyMessage(message, signature) => string<[[address]]> @<utils-verifymessage> @SRC<wallet>
_property: ethers.utils.verifyMessage(message, signature) => string<[[address]]> @<utils-verifyMessage> @SRC<wallet>
Returns the address that signed //message// producing //signature//. The
signature may have a non-canonical v (i.e. does not need to be 27 or 28),
in which case it will be normalized to compute the `recoveryParam` which
@ -39,9 +39,9 @@ will then be used to compute the address; this allows systems which use
the v to encode additional data (such as [EIP-155](link-eip-155))
to be used since the v parameter is still completely non-ambiguous.
_property: ethers.utils.recoverPublicKey(digest, signature) => string<[[datahexstring]]<65>> @<utils-recoverpublickey>
_property: ethers.utils.recoverPublicKey(digest, signature) => string<[[DataHexString]]<65>> @<utils-recoverPublicKey>
_property: ethers.utils.computePublicKey(key [, compressed = false ]) => string<[[datahexstring]]> @<utils-computepublickey>
_property: ethers.utils.computePublicKey(key [, compressed = false ]) => string<[[DataHexString]]> @<utils-computePublicKey>
Computes the public key of //key//, optionally compressing it. The //key//
can be any form of public key (compressed or uncompressed) or a private
key.

40
docs.wrm/api/utils/strings.wrm
View File

@ -1,9 +1,9 @@
_section: Strings
_section: Strings @<strings>
Tra la la
_subsection: Bytes32String @<bytes32-string>
_subsection: Bytes32String @<Bytes32String>
A string in Solidity is length prefixed with its 256-bit (32 byte)
length, which means that even short strings require 2 words (64 bytes)
@ -19,23 +19,23 @@ _note: Note
Strings that are 31 __//bytes//__ long may contain fewer than 31 __//characters//__,
since UTF-8 requires multiple bytes to encode international characters.
_property: ethers.utils.parseBytes32String(aBytesLike) => string @<utils-parsebytes32> @SRC<strings>
_property: ethers.utils.parseBytes32String(aBytesLike) => string @<utils-parseBytes32> @SRC<strings>
Returns the decoded string represented by the ``Bytes32`` encoded data.
_property: ethers.utils.formatBytes32String(text) => string<[[datahexstring]]<32>> @<utils-formatbytes32> @SRC<strings>
_property: ethers.utils.formatBytes32String(text) => string<[[DataHexString]]<32>> @<utils-formatBytes32> @SRC<strings>
Returns a ``bytes32`` string representation of //text//. If the
length of //text// exceeds 31 bytes, it will throw an error.
_subsection: UTF-8 Strings @<utf8-string>
_subsection: UTF-8 Strings @<strings-utf8>
_property: ethers.utils.toUtf8Bytes(text [ , form = current ] ) => Uint8Array @<utils-toutf8bytes> @SRC<strings>
_property: ethers.utils.toUtf8Bytes(text [ , form = current ] ) => Uint8Array @<utils-toUtf8Bytes> @SRC<strings>
Returns the UTF-8 bytes of //text//, optionally normalizing it using the
[[unicode-normalization-form]] //form//.
[[strings--unicode-normalization-form]] //form//.
_property: ethers.utils.toUtf8CodePoints(text [ , form = current ] ) => Array<number> @<utils-toutf8codepoints> @SRC<strings>
_property: ethers.utils.toUtf8CodePoints(text [ , form = current ] ) => Array<number> @<utils-toUtf8CodePoints> @SRC<strings>
Returns the Array of codepoints of //text//, optionally normalized using the
[[unicode-normalization-form]] //form//.
[[strings--unicode-normalization-form]] //form//.
_note: Note
This function correctly splits each **user-perceived character** into
@ -43,14 +43,14 @@ its codepoint, accounting for surrogate pairs. This should not be confused with
``string.split("")``, which destroys surrogate pairs, spliting between each UTF-16
codeunit instead.
_property: ethers.utils.toUtf8String(aBytesLike [ , onError = error ] ) => string @<utils-toutf8string> @SRC<strings>
_property: ethers.utils.toUtf8String(aBytesLike [ , onError = error ] ) => string @<utils-toUtf8String> @SRC<strings>
Returns the string represented by the UTF-8 bytes of //aBytesLike//.
The //onError// is a [Custom UTF-8 Error function](utf8error) and if not specified
it defaults to the [error](utf8error-error) function, which throws an error
The //onError// is a [Custom UTF-8 Error function](strings--error-handling) and if not specified
it defaults to the [error](strings--Utf8Error) function, which throws an error
on **any** UTF-8 error.
_subsection: UnicodeNormalizationForm @<unicode-normalization-form> @SRC<strings/utf8:enum.UnicodeNormalizationForm>
_subsection: UnicodeNormalizationForm @<strings--unicode-normalization-form> @SRC<strings/utf8:enum.UnicodeNormalizationForm>
There are several [commonly used forms](link-wiki-unicode-equivalence)
when normalizing UTF-8 data, which allow strings to be compared or hashed in a stable
@ -91,7 +91,8 @@ Only certain specified characters are folded in Canonical Equivalence, and thus
it should **not** be considered a method to acheive //any// level of security from
[homoglyph attacks](link-wiki-homoglyph).
_subsection: Custom UTF-8 Error Handling @<utf8error>
_subsection: Custom UTF-8 Error Handling @<strings--error-handling>
When converting a string to its codepoints, there is the possibility
of invalid byte sequences. Since certain situations may need specific
@ -99,7 +100,7 @@ ways to handle UTF-8 errors, a custom error handling function can be used,
which has the signature:
_property: errorFunction(reason, offset, bytes, output [ , badCodepoint ]) => number
The //reason// is one of the [UTF-8 Error Reasons](utf8error-reasons), //offset// is the index
The //reason// is one of the [UTF-8 Error Reasons](strings--error-reasons), //offset// is the index
into //bytes// where the error was first encountered, output is the list
of codepoints already processed (and may be modified) and in certain Error
Reasons, the //badCodepoint// indicates the currently computed codepoint,
@ -108,7 +109,8 @@ but which would be rejected because its value is invalid.
This function should return the number of bytes to skip past keeping in
mind the value at //offset// will already be consumed.
_heading: UTF-8 Error Reasons @<utf8error-reasons> @SRC<strings/utf8:Utf8ErrorReason>
_heading: UTF-8 Error Reasons @<strings--error-reasons> @SRC<strings/utf8:Utf8ErrorReason>
_property: ethers.utils.Utf8ErrorReason.BAD_PREFIX
A byte was encountered which is invalid to begin a UTF-8 byte
@ -166,16 +168,16 @@ _heading: Provided UTF-8 Error Handling Functions
There are already several functions available for the most common
situations.
_property: ethers.utils.Utf8ErrorFuncs.error @<utf8error-error> @SRC<strings/utf8:errorFunc>
_property: ethers.utils.Utf8ErrorFuncs.error @<strings--Utf8Error> @SRC<strings/utf8:errorFunc>
The will throw an error on **any** error with a UTF-8 sequence, including
invalid prefix bytes, overlong sequences, UTF-16 surrogate pairs.
_property: ethers.utils.Utf8ErrorFuncs.ignore @<utf8error-ignore> @SRC<strings/utf8:ignoreFunc>
_property: ethers.utils.Utf8ErrorFuncs.ignore @<strings--Utf8Ignore> @SRC<strings/utf8:ignoreFunc>
This will drop all invalid sequences (by consuming invalid prefix bytes and
any following continuation bytes) from the final string as well as permit
overlong sequences to be converted to their equivalent string.
_property: ethers.utils.Utf8ErrorFuncs.replace @<utf8error-replace> @SRC<strings/utf8:replaceFunc>
_property: ethers.utils.Utf8ErrorFuncs.replace @<strings--Utf8Replace> @SRC<strings/utf8:replaceFunc>
This will replace all invalid sequences (by consuming invalid prefix bytes and
any following continuation bytes) with the
[UTF-8 Replacement Character](link-wiki-utf8-replacement),

40
docs.wrm/api/utils/transactions.wrm
View File

@ -1,8 +1,8 @@
_section: Transactions @<utils-transactions>
_section: Transactions @<transactions>
_subsection: Types
_heading: UnsignedTransaction @<types-unsignedtransaction>
_heading: UnsignedTransaction @<UnsignedTransaction>
An unsigned transaction represents a transaction that has not been
signed and its values are flexible as long as they are not ambiguous.
@ -12,16 +12,16 @@ The addres this transaction is to.
_property: unsignedTransaction.nonce => number
The nonce of this transaction.
_property: unsignedTransaction.gasLimit => [[bignumberish]]
_property: unsignedTransaction.gasLimit => [[BigNumberish]]
The gas limit for this transaction.
_property: unsignedTransaction.gasPrice => [[bignumberish]]
_property: unsignedTransaction.gasPrice => [[BigNumberish]]
The gas price for this transaction.
_property: unsignedTransaction.data => [[byteslike]]
_property: unsignedTransaction.data => [[BytesLike]]
The data for this transaction.
_property: unsignedTransaction.value => [[bignumberish]]
_property: unsignedTransaction.value => [[BigNumberish]]
The value (in wei) for this transaction.
_property: unsignedTransaction.chainId => number
@ -30,10 +30,10 @@ then [[link-eip-155]] is disabled and legacy signing is
used, unless overridden in a signature.
_heading: Transaction @<types-transaction>
_heading: Transaction @<Transaction>
A generic object to represent a transaction.
_property: transaction.hash => string<[[datahexstring]]<32>>
_property: transaction.hash => string<[[DataHexString]]<32>>
The transaction hash, which can be used as an identifier for
//transaction//. This is the keccak256 of the serialized RLP encoded
representation of //transaction//.
@ -50,20 +50,20 @@ from an account includes this, which ensures the order and
non-replayability of a transaction. This must be equal to the current
number of transactions ever sent to the network by the **from** address.
_property: transaction.gasLimit => [[bignumber]]
_property: transaction.gasLimit => [[BigNumber]]
The gas limit for //transaction//. An account must have enough ether to
cover the gas (at the specified **gasPrice**). Any unused gas is
refunded at the end of the transaction, and if there is insufficient gas
to complete execution, the effects of the trasaction are reverted, but
the gas is **fully consumed** and an out-of-gas error occurs.
_property: transaction.gasPrice => [[bignumber]]
_property: transaction.gasPrice => [[BigNumber]]
The price (in wei) per unit of gas for //transaction//.
_property: transaction.data => [[byteslike]]
_property: transaction.data => [[BytesLike]]
The data for //transaction//. In a contract this is the call data.
_property: transaction.value => [[bignumber]]
_property: transaction.value => [[BigNumber]]
The value (in wei) for //transaction//.
_property: transaction.chainId => number
@ -80,12 +80,12 @@ There are situations where replay may be desired, however these
are very rare and it is almost always recommended to specify the
chain ID.
_property: transaction.r => string<[[datahexstring]]<32>>
_property: transaction.r => string<[[DataHexString]]<32>>
The r portion of the elliptic curve signatures for //transaction//.
This is more accurately, the x coordinate of the point r (from
which the y can be computed, along with v).
_property: transaction.s => string<[[datahexstring]]<32>>
_property: transaction.s => string<[[DataHexString]]<32>>
The s portion of the elliptic curve signatures for //transaction//.
_property: transaction.v => number
@ -97,18 +97,10 @@ used to encode the chain ID into the serialized transaction.
_subsection: Functions
_property: ethers.utils.computeAddress(publicOrPrivateKey) => string<[Address](address)> @<utils-computeaddress> @SRC<transactions>
Compute the address of //publicOrPrivateKey//. If a public key is
provided, it may be either compressed or uncompressed.
_property: ethers.utils.parse(aBytesLike) => [[types-transaction]] @<utils-parse> @SRC<transactions>
_property: ethers.utils.parseTransaction(aBytesLike) => [[Transaction]] @<utils-parseTransaction> @SRC<transactions:parse>
Parses the transaction properties from a serialized transactions.
_property: ethers.utils.recoverAddress(digest, aSignatureLike) => string<[Address](address)> @<utils-recoveraddress> @SRC<transactions>
Computes the address that signed //digest// to get //aSignatureLike// using the
ecrecover algorithm.
_property: ethers.utils.serialize(transaction [ , signature ]) => string<[[datahexstring]]> @<utils-serialize> @SRC<transactions>
_property: ethers.utils.serializeTransaction(tx [ , signature ]) => string<[[DataHexString]]> @<utils-serializeTransaction> @SRC<transactions:serialize>
Computes the serialized //transaction//, optionally serialized with
the a //signature//. If //signature// is not present, the unsigned
serialized transaction is returned, which can be used to compute the

19
docs.wrm/api/utils/web.wrm
View File

@ -1,17 +1,17 @@
_section: Web Utilities
_section: Web Utilities @<web>
_property: ethers.utils.fetchJson(urlOrConnectionInfo [, json [ , processFunc ] ]) => Promise<any> @<web-fetchjson>
_property: ethers.utils.fetchJson(urlOrConnectionInfo [, json [ , processFunc ] ]) => Promise<any> @<utils-fetchJson>
Fetch and parse the JSON content from //urlOrConnectionInfo//, with the
optiona body //json// and optionally processing the result with //processFun//
before returning it.
_property: ethers.utils.poll(pollFunc [, options ]) => Promise<any> @<web-poll>
Repeatedly call pollFunc using the [[web-polloptions]] until it returns a
_property: ethers.utils.poll(pollFunc [, options ]) => Promise<any> @<utils-poll>
Repeatedly call pollFunc using the [[PollOptions]] until it returns a
value other than undefined.
_heading: Connection Info @<web-connectioninfo>
_heading: ConnectionInfo @<ConnectionInfo>
_property: connection.url => string
The URL to connect to.
@ -34,7 +34,7 @@ _property: connection.headers => { [ key: string]: string }
Additional headers to include in the connection.
_heading: Poll Options @<web-polloptions>
_heading: PollOptions @<PollOptions>
_property: options.timeout => number
The amount of time allowed to ellapse before triggering a timeout
@ -59,6 +59,11 @@ _property: options.retryLimit => number
The number of times to retry in the event of an error or //undefined// is
returned.
_property: options.onceBlock => [[provider]]
_property: options.onceBlock => [[Provider]]
If this is specified, the polling will wait on new blocks from
//provider// before attempting the //pollFunc// again.
_property: options.oncePoll => [[Provider]]
If this is specified, the polling will occur on each poll
cycle of //provider// before attempting the //pollFunc//
again.

24
docs.wrm/api/utils/wordlists.wrm
View File

@ -1,6 +1,6 @@
_section: Wordlists @<wordlists>
_subsection: Wordlist @<wordlist>
_subsection: Wordlist @<Wordlist>
_property: wordlist.locale => string
The locale for this wordlist.
@ -19,7 +19,7 @@ _property: wordlist.join(words) => string
Returns the mnemonic by joining //words// together using the
whitespace that is standard for the locale.
_property: Wordlist.check(wordlists) => string<[[datahexstring]]<32>>
_property: Wordlist.check(wordlists) => string<[[DataHexString]]<32>>
Checks that all words map both directions correctly and return the
hash of the lists. Sub-classes should use this to validate the wordlist
is correct against the official wordlist hash.
@ -28,31 +28,31 @@ _property: Wordlist.register(wordlist [ , name ]) => void
Register a wordlist with the list of wordlists, optionally overriding
the registered //name//.
_subsection: Languages @<wordlist-languages>
_subsection: Languages @<wordlists--languages>
_property: ethers.wordlists.cz => Wordlist
The Czech [[wordlist]].
The Czech [[Wordlist]].
_property: ethers.wordlists.en => Wordlist
The English [[wordlist]].
The English [[Wordlist]].
_property: ethers.wordlists.es => Wordlist
The Spanish [[wordlist]].
The Spanish [[Wordlist]].
_property: ethers.wordlists.fr => Wordlist
The French [[wordlist]].
The French [[Wordlist]].
_property: ethers.wordlists.it => Wordlist
The Italian [[wordlist]].
The Italian [[Wordlist]].
_property: ethers.wordlists.ja => Wordlist
The Japanese [[wordlist]].
The Japanese [[Wordlist]].
_property: ethers.wordlists.ko => Wordlist
The Korean [[wordlist]].
The Korean [[Wordlist]].
_property: ethers.wordlists.zh_cn => Wordlist
The Simplified Chinese [[wordlist]].
The Simplified Chinese [[Wordlist]].
_property: ethers.wordlists.zh_tw => Wordlist
The Traditional Chinese [[wordlist]].
The Traditional Chinese [[Wordlist]].

14
docs.wrm/cli/asm.wrm
View File

@ -27,9 +27,7 @@ OTHER OPTIONS
_subsection: Example Input Files
_definition: **SimpleStore.asm**
_code: @lang<asm>
_code: SimpleStore.asm @lang<asm>
; SimpleStore (uint)
@ -76,14 +74,16 @@ return(0, #myContract)
; There is no *need* for the PUSH32, it just makes
; decompiled code look nicer
@checksum[
{{= (defines.checksum ? concat([ Opcode.from("PUSH32"), id(myContract.source) ]): "0x") }}
{{= (defines.checksum ? concat([
Opcode.from("PUSH32"),
id(myContract.source)
]): "0x")
}}
]
}
_definition: **SimpleStore.bin**
_code: @lang<text>
_code: SimpleStore.bin @lang<text>
0x602a6000556044601160003960446000f334601e5760003560e01c8063209652
0x5514602457806355241077146030575b60006000fd5b60005460005260206000

58
docs.wrm/cli/ethers.wrm
View File

@ -78,9 +78,7 @@ OTHER OPTIONS
_subsection: Examples
_heading: Creating Wallets @<cliex-init>
_code: @lang<shell>
_code: Creating New Wallets @lang<shell> @<cliex-init>
/home/ethers> ethers init wallet.json
Creating a new JSON Wallet - wallet.json
@ -98,9 +96,7 @@ Saved: wallet.json
Transaction Hash: 0x8dc55b8f8dc8076acded97f9e3ed7d6162460c0221e2769806006b6d7d1156e0
_heading: Sending Ether and Tokens @<cliex-send>
_code: @lang<shell>
_code: Sending Ether and Tokens @<cliex-send> @lang<shell>
# Sending ether
/home/ricmoo> ethers --account wallet.json send ricmoo.firefly.eth 0.123
@ -147,9 +143,7 @@ Response:
Hash: 0xd609ecb7e3b5e8d36fd781dffceede3975ece6774b6322ea56cf1e4d0a17e3a1
_heading: Signing Messages @<cliex-signing>
_code: @lang<shell>
_code: Signing Messages @<cliex-signing> @lang<shell>
/home/ethers> ethers --account wallet.json sign-message 'Hello World'
Password (wallet.json): ******
@ -173,25 +167,47 @@ The ``eval`` command can be used to execute simple one-line scripts from
the command line to be passed into other commands or stored in script
environment variables.
_code: @lang<shell>
# Get the formatted balance of an account
/home/ethers> ethers --network ropsten --account wallet.json eval 'accounts[0].getBalance().then(b => formatEther(b))'
_code: Get the formatted balance of an account @lang<shell>
/home/ethers> ethers --network ropsten \
--account wallet.json \
eval \
'accounts[0].getBalance().then(b => formatEther(b))'
3.141592653589793238
# Get the current block number
/home/ethers> ethers --network rinkeby eval "provider.getBlockNumber()"
_code: Get the current block number @lang<shell>
/home/ethers> ethers --network rinkeby \
eval "provider.getBlockNumber()"
5761009
# Convert a Solidity signature to JSON
/home/ethers> ethers eval 'utils.Fragment.from("function balanceOf(address owner) view returns (uint)").format("json")'
{"type":"function","name":"balanceOf","constant":true,"stateMutability":"view","payble":false,"inputs":[{"type":"address","name":"owner"}],"ouputs":[{"type":"uint256"}]}
_code: Convert a Solidity signature to JSON @lang<shell>
/home/ethers> ethers eval 'utils.Fragment.from(
"function balanceOf(address) view returns (uint)"
).format("json")' | json_pp
{
"inputs" : [
{
"type" : "address",
"name" : "owner"
}
],
"type" : "function",
"payble" : false,
"stateMutability" : "view",
"ouputs" : [
{
"type" : "uint256"
}
],
"name" : "balanceOf",
"constant" : true
}
# Compute a topic hash
_code: Compute a topic hash @lang<shell>
/home/ricmoo> ethers eval 'id("Transfer(address,address,uint256")'
0xd99659a21de82e379975ce8df556f939a4ccb95e92144f38bb0dd35730ffcdd5
# Create a random mnemonic
_code: Create a random mnemonic @lang<shell>
/home/ricmoo> ethers eval 'Wallet.createRandom().mnemonic'
useful pond inch knock ritual matrix giggle attend dilemma convince coach amazing
@ -205,7 +221,7 @@ use to decrypt the account.
_code: @lang<shell>
/home/ricmoo> ethers --account public-mnemonic.txt --mnemonic-password
/home/ricmoo> ethers --account mnemonic.txt --mnemonic-password
Password (mnemonic): ******
network: homestead (chainId: 1)
homestead> accounts[0].getAddress()

10
docs.wrm/cli/plugin.wrm
View File

@ -54,20 +54,20 @@ make sense.
Once the prepareArguments is complete (the returned promise is resolved), the ``run``
is called.
_property: plugin.network => [[provider-network]]
_property: plugin.network => [[providers-Network]]
The network this plugin is running for.
_property: plugin.provider => [[provider]]
_property: plugin.provider => [[Provider]]
The provider for this plugin is running for.
_property: plugin.accounts => Array<[[signer]]>
_property: plugin.accounts => Array<[[Signer]]>
The accounts passed into the plugin using ``--account``,
``--account-rpc`` and ``--account-void`` which this plugin can use.
_property: plugin.gasLimit => [[bignumber]]
_property: plugin.gasLimit => [[BigNumber]]
The gas limit this plugin should use. This is null if unspecified.
_property: plugin.gasPrice => [[bignumber]]
_property: plugin.gasPrice => [[BigNumber]]
The gas price this plugin should use. This is null if unspecified.
_property: plugin.nonce => number

150
docs.wrm/concepts/events.wrm
View File

@ -5,3 +5,153 @@ Explain how topics and such work
_subsection: Solidity Topics
How to compute the topic...
_subsection: Logs and Filtering
Example hog logs are used.
Link to provider.getLogs and contract.on
_heading: Filters
Filter are used as a way to query ... efficient, explain bloom filters lightly
A filter may have up to 4 topic-sets, where each topic-set refers
to a condition that must match the log topic in that position (i.e. each
condition is ``AND``-ed together).
If a topic-set is ``null``, a log topic in that position is not filtered
at all and **any value** matches.
If a topic-set is a single topic, a log topic in that position must match
**that topic**.
If a topic-set is an array of topics, a log topic in that position must
match any **one** of topics (i.e. the topic in thie position are ``OR``-ed).
_table: Example Log Matching @style<full>
$TopicABaCD: **[** (topic[0] = A) **OR** (topic[0] = B) **]** **AND**
**[** (topic[1] = C) **OR** (topic[1] = D) **]**
| **Topic-Sets** | **Matching Logs** <<|
| [ A ] | topic[0] = A <<|
| [ A, null ] | ^ |
| [ null, B ] | topic[1] = B <<|
| [ null, [ B ] ] | ^ |
| [ null, [ B ], null ] | ^ |
| [ A, B ] | (topic[0] = A) **AND** (topic[1] = B) <<|
| [ A, [ B ] ] | ^ |
| [ A, [ B ], null ] | ^ |
| [ [ A, B ] ] | (topic[0] = A) **OR** (topic[0] = B) <<|
| [ [ A, B ], null ] | ^ |
| [ [ A, B ], [ C, D ] ] | $TopicABaCD <<|
_code: ERC-20 Transfer Filter Examples @lang<javascript>
// <hide>
const tokenAddress = ethers.constants.AddressZero;
const myAddress = ethers.constants.AddressZero;
const myOtherAddress = ethers.constants.AddressZero;
const id = ethers.utils.id;
const hexZeroPad = ethers.utils.hexZeroPad;
// </hide>
// Short example of manually creating filters for an ERC-20
// Transfer event.
//
// Most users should generally use the Contract API to
// compute filters, as it is much simpler, but this is
// provided as an illustration for those curious. See
// below for examples of the equivalent Contract API.
// ERC-20:
// Transfer(address indexed src, address indexed dst, uint val)
//
// -------------------^
// ----------------------------------------^
//
// Notice that only *src* and *dst* are *indexed*, so ONLY they
// qualify for filtering.
//
// Also, note that in Solidity an Event uses the first topic to
// identify the Event name; for Transfer this will be:
// id("Transfer(address,address,uint256)")
//
// Other Notes:
// - A topic must be 32 bytes; so shorter types must be padded
// List all token transfers *from* myAddress
filter = {
address: tokenAddress,
topics: [
id("Transfer(address,address,uint256)"),
hexZeroPad(myAddress, 32)
]
}
// List all token transfers *to* myAddress:
filter = {
address: tokenAddress,
topics: [
id("Transfer(address,address,uint256)"),
null,
hexZeroPad(myAddress, 32)
]
}
// List all token transfers *to* myAddress or myOtherAddress:
filter = {
address: tokenAddress,
topics: [
id("Transfer(address,address,uint256)"),
null,
[
hexZeroPad(myAddress, 32),
hexZeroPad(myOtherAddress, 32),
]
]
}
_null:
To simplify life, ..., explain here, the contract API
_code: ERC-20 Contract Filter Examples @lang<javascript>
// <hide>
const tokenAddress = "0x6B175474E89094C44Da98b954EedeAC495271d0F"; // DAI
const myAddress = "0x8ba1f109551bD432803012645Ac136ddd64DBA72";
const otherAddress = "0xEA517D5a070e6705Cc5467858681Ed953d285Eb9";
const provider = ethers.getDefaultProvider();
const Contract = ethers.Contract;
// </hide>
const abi = [
"event Transfer(address indexed src, address indexed dst, uint val)"
];
const contract = new Contract(tokenAddress, abi, provider);
// List all token transfers *from* myAddress
contract.filters.Transfer(myAddress)
//!
// List all token transfers *to* myAddress:
contract.filters.Transfer(null, myAddress)
//!
// List all token transfers *from* myAddress *to* otherAddress:
contract.filters.Transfer(myAddress, otherAddress)
//!
// List all token transfers *to* myAddress OR otherAddress:
contract.filters.Transfer(null, [ myAddress, otherAddress ])
//!
_heading: Other Things? TODO
Explain what happens to strings and bytes, how to filter and retain the value

56
docs.wrm/config.js
View File

@ -116,6 +116,7 @@ const getSourceUrl = (function(path, include, exclude) {
})("../packages/", new RegExp("packages/.*/src.ts/.*\.ts$"), new RegExp("/node_modules/|src.ts/.*browser.*"));
function codeContextify(context) {
const { inspect } = require("util");
const ethers = context.require("./packages/ethers");
context.ethers = ethers;
@ -127,16 +128,45 @@ function codeContextify(context) {
context.hexValue = ethers.utils.hexValue;
context.Wallet = ethers.Wallet;
context._inspect = function(value) {
context.BigNumber.prototype[inspect.custom] = function(depth, options) {
return `{ BigNumber: ${JSON.stringify(this.toString()) } }`;
}
context._inspect = function(value, depth) {
/*
if (context.BigNumber.isBigNumber(value)) {
return `{ BigNumber: ${ JSON.stringify(value.toString()) } }`;
}
if (value && typeof(value.length) === "number" && typeof(value) !== "string") {
return "[ " + Array.prototype.map.call(value, (i) => context._inspect(i)).join(", ") + " ]";
return "[ " + Array.prototype.map.call(value, (i) => context._inspect(i, (depth || 0) + 1)).join(", ") + " ]";
}
return JSON.stringify(value);
if (typeof(value) === "object" && depth == null) {
const keys = Object.keys(value);
keys.sort();
value = keys.reduce((accum, key) => {
accum[key] = value[key];
return accum;
}, { });
*/
/*
return [
"{",
keys.map((key) => {
return ` ${key}: ${ context._inspect(value[key], 1) },`;
}).join("\n"),
"}"
].join("\n");
*/
//}
//return JSON.stringify(value);
return inspect(value, {
compact: false,
sorted: true,
});
}
}
@ -145,8 +175,8 @@ module.exports = {
subtitle: "v5.0-beta",
logo: "logo.svg",
link: "https://docs-beta.ethers.io",
copyright: "The content of this site is licensed under the [Creative Commons Attribution 4.0 International License](https://choosealicense.com/licenses/cc-by-4.0/).",
link: "https:/\/docs-beta.ethers.io",
copyright: "The content of this site is licensed under the [Creative Commons License](https:/\/choosealicense.com/licenses/cc-by-4.0/). Generated on &$now;.",
markdown: {
"banner": "-----\n\nDocumentation: [html](https://docs-beta.ethers.io/)\n\n-----\n\n"
@ -165,19 +195,27 @@ module.exports = {
"link-etherscan": "https:/\/etherscan.io",
"link-etherscan-api": "https:/\/etherscan.io/apis",
"link-flatworm": "https:/\/github.com/ricmoo/flatworm",
"link-geth": "https:/\/geth.ethereum.org",
"link-infura": "https:/\/infura.io",
"link-geth": { name: "Geth", url: "https:/\/geth.ethereum.org" },
"link-infura": { name: "INFURA", url: "https:/\/infura.io" },
"link-ledger": "https:/\/www.ledger.com",
"link-metamask": "https:/\/metamask.io/",
"link-parity": "https:/\/www.parity.io",
"link-metamask": { name: "Metamask", url: "https:/\/metamask.io/" },
"link-parity": { name: "Parity", url: "https:/\/www.parity.io" },
"link-rtd": "https:/\/github.com/readthedocs/sphinx_rtd_theme",
"link-semver": { name: "semver", url: "https:/\/semver.org" },
"link-solidity": { name: "Solidity" , url: "https:/\/solidity.readthedocs.io/en/v0.6.2/" },
"link-sphinx": "https:/\/www.sphinx-doc.org/",
"link-json-rpc": "https:/\/github.com/ethereum/wiki/wiki/JSON-RPC",
"link-parity-trace": "https:/\/openethereum.github.io/wiki/JSONRPC-trace-module",
"link-parity-rpc": "https:/\/openethereum.github.io/wiki/JSONRPC",
"link-geth-debug": "https:/\/github.com/ethereum/go-ethereum/wiki/Management-APIs#debug",
"link-geth-rpc": "https:/\/github.com/ethereum/go-ethereum/wiki/Management-APIs",
"link-legacy-docs3": "https:/\/docs.ethers.io/ethers.js/v3.0/html/",
"link-legacy-docs4": "https:/\/docs.ethers.io/ethers.js",
"link-infura-secret": "https:/\/infura.io/docs/gettingStarted/authentication",
"link-web3": "https:/\/github.com/ethereum/web3.js",
"link-web3-http": "https:/\/github.com/ethereum/web3.js/tree/1.x/packages/web3-providers-http",
"link-web3-ipc": "https:/\/github.com/ethereum/web3.js/tree/1.x/packages/web3-providers-ipc",

350
docs.wrm/documentation.wrm
View File

@ -1,6 +1,6 @@
_section: Flatworm Docs
The //Flatworm Docs// rendering script is designed to be **very**
The //Flatworm Docs// rendering engine is designed to be **very**
simple, but provide enough formatting necessary for documenting
JavaScript libraries.
@ -10,10 +10,12 @@ the [Sphinx](link-sphinx) project.
_subsection: Fragments @<flatworm-fragments>
Flatworm Docs are made up of fragments. A fragment is either a lone
body of [markdown](flatworm-markdown) text, or a
[directive](flatworm-directive) for specialized formatting, which may
itself have body.
Each page is made up of fragments. A fragment is a [directive](flatworm-directive),
with an value and optional //link//, //extensions// and a body.
Many directives support [markdown](flatworm-markdown) in their value and body.
A fragment's body continues until another fragment is encountered.
_heading: Directive Format
@ -23,6 +25,8 @@ _code: @lang<text>
\_DIRECTIVE: VALUE @<LINK> @EXTENSION<PARAMETER>
BODY
MORE BODY
DIRECTIVE: The directive name
VALUE: Optional; the value to pass to the directive
LINK: Optional; a name for internal linking
@ -36,97 +40,138 @@ _heading: Flatworm Directives @<flatworm-directive>
_definition: **_section:** //TITLE//
A //section// has its **TITLE** in an H1 font. Sections are linked
to in //Table of Contents// and have a dividing line drawn above
them. If an option is specified, it is avaialble as a name for
intern linking. There should only be one ``_section:`` per page.
them.
**Extensions:** @INHERIT, @SRC, @NAV, @NOTE
The body supports markdown.
There should only be one ``_section:`` per page.
**Extensions:** [@inherit](flatworm--ext-inherit), [@src](flatworm--ext-src), [@nav](flatworm--ext-nav), [@note](flatworm--ext-note)
_definition: **_subsection:** //TITLE//
A //subsection// has its **TITLE** in an H2 font. Subsections are linked
to in //Table of Contents// and have a dividing line drawn above
them. If an option is specified, it is avaialble as a name for
internal linking.
them.
**Extensions:** @INHERIT, @SRC, @NOTE
The title and body support markdown.
**Extensions:** [@inherit](flatworm--ext-inherit), [@src](flatworm--ext-src), [@note](flatworm--ext-note)
_definition: **_heading:** //TITLE//
A //heading// has its **TITLE** in an H3 font. If an option is specified,
it is available as a name for internal linking.
A //heading// has its **TITLE** in an H3 font.
**Extensions:** @INHERIT, @SRC, @NOTE
The title and body support markdown.
**Extensions:** [@inherit](flatworm--ext-inherit), [@src](flatworm--ext-src), [@note](flatworm--ext-note)
_definition: **_definition:** //TERM//
A //definition// has its **TERM** bolded and the markdown body is
A //definition// has its **TERM** in normal text and the body is
indented.
The title and body support markdown.
_definition: **_property:** //SIGNATURE//
A //property// has its JavaScript **SIGNATURE** formatted and the
markdown body is indented.
A //property// has its JavaScript **SIGNATURE** formatted.
**Extensions:** @SRC
The body supports markdown and the return portion of the signature
support markdown links.
_definition: **_note:** //TITLE//
**Extensions:** [@src](flatworm--ext-src)
_definition: **_note:** //BANNER//
A //note// is placed in a blue bordered-box to draw attention to it.
_definition: **_warning:** //TITLE//
The body supports markdown.
_definition: **_warning:** //BANNER//
A //warning// is placed in an orange bordered-box to draw attention to it.
_definition: **_code:** //TITLE//
A //code// creates a code block.
The body supports markdown.
**Extensions:** @LANG
_definition: **_code:** //CAPTION//
Creates a [Code](flatworm--code) block.
For JavaScript files, the file is executed, with ``\/\/!`` replaced
with the result of the last statement and ``\/\/!error`` is replaced
with the throw error. If the error state does not agree, rendering
fails.
The body does **not** support markdown, and will be output exactly as
is, with the exception of [Code Evaluation](flatworm--code-eval).
If a line begins with a ``"_"``, it should be escaped with a ``"\\"``.
**Extensions:** [@lang](flatworm--ext-lang)
_definition: **_table:** //FOOTER//
Creates a [Table](flatworm--table) structured according to the body.
Each cell support and variables support markdown.
**Extensions:** [@style](flatworm--ext-style)
_definition: **_toc:**
A //toc// injects a Table of Contents, loading each line of the
body as a filename and recursively loads the //toc// if present,
otherwise all the //sections// and //subsections//.
The body does **not** support markdown, as it is interpreted as
a list of files and directories to process.
_definition: **_null:**
A //null// is used to terminated a directive. For example, after
a //definition//, the bodies are indented, so a //null// can be
used to reset the indentation.
The body supports markdown.
_heading: Examples @<>
_code: Example @lang<text>
_code: @lang<text>
\_section: Hello World @<link-main>
Body for section...
\_section: Hello World @<link-to-this-section>
\_subsection: Some Example @<link-to-this-subsection>
\_subsection: Some Example @<link-secondary>
Body for subsection...
\_heading: Large Bold Text @<link-here>
Body for heading...
\_heading: Large Bold Text @<link-to-this-heading>
\_definition: Flatworm
A phylum of relatively **simple** bilaterian, unsegmented,
soft-bodied invertebrates.
\_property: String.fromCharCode(code) => string
Returns a string created from //code//, a sequence of
UTF-16 code units.
\_code: heading
// Some code goes here
while(1);
\_table: Table Footer
| **Name** | **Color** |
| Apple | Red |
| Banana | Yellow |
| Grape | Purple |
\_toc:
some-file
some-directory
\_definition and reset the indentation.
\_note: Title
This is placed in a blue box.
\_warning: Title
This is placed in an orange box.
\_null:
This breaks out of a directive. For example, to end a
@ -138,6 +183,9 @@ other dialects, but allows for **bold**, //italic//,
__underlined__, ``monospaced``, super^^script^^ and ~~strike~~
text, supporting [links](flatworm-markdown) and lists.
Lists are rendered as blocks of a body, so cannot be used within
a title or within another list.
_code: @lang<text>
**bold text**
@ -163,6 +211,216 @@ This is a self-titled link [[https://ethereumorg]] and this
[[some-link]] will use the title from its directives value.
_subsection: Code @<flatworm--code>
The code directive creates a monospace, contained block useful
for displaying code samples.
_heading: JavaScript Evaluation @<flatworm--code-eval>
For JavaScript files, the file is executed with some simple substitution.
A bare ``\/\/!`` on a line is replaced with the result of the last
statement. Building will fail if an error is thrown.
A bare ``\/\/!error`` is replaced with the throw error. Building will
fail if an error is not thrown.
Also any code included between the lines **``\/\/ <hide>``** and
**``\/\/ </hide>``** will be omitted from the output, which can be used
to setup variables.
_code: Code Evaluation Example @lang<text>
\_code: Result of Code Example @lang<javascript>
// <hide>
const url = require("url");
// </hide>
url.parse("https://www.ricmoo.com/").protocol
//!
url.parse(45)
//! error
// You want to assign (doesn't emit eval) AND display the value
const foo = 4 + 5;
// <hide>
foo
// </hide>
//!
_code: Result of Code Example @lang<javascript>
// <hide>
const url = require("url");
// </hide>
url.parse("https://www.ricmoo.com/").protocol
//!
url.parse(45)
//! error
// You want to assign (doesn't emit eval) AND display the value
const foo = 4 + 5;
// <hide>
foo
// </hide>
//!
_heading: Languages
The language can be specified using the [@lang extension](flatworm--ext-lang).
_table:
| **Language** | **Notes** |
| javascript | Syntax highlights and [evaluates](flatworm--code-eval) the JavaScipt |
| script | Same as ``javascript``, but does not evaluate the results |
| shell | Shell scripts or command-line |
| text | Plain text with no syntax highlighting |
_subsection: Tables @<flatworm--table>
The table directive consumes the entire body up until the next
directive. To terminate a table early to begin a text block,
use a **_null:** directive.
Each line of the body should be [Row Data](flatworm--table-row) or a
[Variable Declaration](flatworm--table-variable) (or continuation of
a //Variable Declaration//). Blank lines are ignored.
_heading: Row Data @<flatworm--table-row>
Each **Row Data** line must begin and end with a **``"|"``**, with each
gap representing the cell data, [alignment](flatworm--table-alignment)
with optional [column and row spanning](flatworm--table-spanning).
_heading: Alignment @<flatworm--table-alignment>
The alignment for a cell is determined by the whitespace surrounding the
cell data.
_table: Alignment Conditions (higher precedence listed first)
| **Alignment** | **Whitespace** |
| //Left// | 1 or fewer spaces before the content |
| //Right// | 1 or fewer spaces after the content |
| //Center// | 2 or more space **both** before and after the content |
_code: Alignment Example @lang<text>
\_table: Result of Alignment Example @style<compact>
| center |
| left |
|left |
| right |
| right|
_table: Result of Alignment Example @style<compact>
| center |
| left |
|left |
| right |
| right|
_heading: Row and Column Spanning @<flatworm--table-spanning>
A column may end its content with any number of **``"<"``** which indicates
how many //additional// columns to extend into.
If the cell content contains only a **``"^"``**, then the row above is
extended into this cell (into the same number of columns).
_code: Cell Spanning Example @lang<text>
\_table: Result of Cell Spanning Example @style<compact>
| (1x1) | (1x2) <| (2x1) |
| (2x2) <| (2x1) | ^ |
| ^ | ^ | (1x1) |
_table: Result of Cell Spanning Example @style<compact>
| (1x1) | (1x2) <| (2x1) |
| (2x2) <| (2x1) | ^ |
| ^ | ^ | (1x1) |
_heading: Styles @<flatworm--table-style>
The [@style extension](flatworm--ext-style) for a table can be used to control its
appearance.
_table:
| **Name** | **Width** | **Columns** |
| //minimal// | minimum size | best fit |
| //compact// | 40% | evenly spaced |
| //wide// | 67% | evenly spaced |
| //full// | 100% | evenly spaced |
_heading: Variables @<flatworm--table-variable>
Often the layout of a table is easier to express and maintain without
uneven or changing content within it. So the content can be defined
separately within a table directive using **variables**. A varaible
name must being with a letter and must only contain letters and numbers.
Variables are also useful when content is repeated throughout a table.
A variable is declared by starting a line with ``"$NAME:"``, which
consumes all lines until the next variable declaration or until the
next table row line.
A variable name must start with a letter and may consist of letters and
numbers. (i.e. ``/[a-z][a-z0-9]*/i``)
_code: Variables Example @lang<text>
\_table: Result of Variables Example
$Yes: This option is supported.
$No: This option is **not** supported
$bottom: This just represents an example of
what is possible. Notice that variable
content can span multiple lines.
| **Feature** | **Supported** |
| Dancing Monkey | $Yes |
| Singing Turtle | $No |
| Newt Hair | $Yes |
| $bottom <|
_table: Result of Variables Example
$Yes: This option is supported.
$No: This option is **not** supported.
$bottom: This just represents an example of
what is possible. Notice that variable
content can span multiple lines.
| **Feature** | **Supported** |
| Dancing Monkey | $Yes |
| Singing Turtle | $No |
| Newt Hair | $Yes |
| $bottom <|
_subsection: Configuration @<flatworm-config>
Configuration is optional (but highly recommended) and may be either
@ -174,38 +432,38 @@ TODO: example JSON and example JS
_subsection: Extensions @<flatworm-extensions>
_heading: @INHERIT\<markdown>
_heading: @inherit\< //markdown// > @<flatworm--ext-inherit>
Adds an inherits description to a directive. The //markdown// may contain links.
_heading: @LANG\<text>
_heading: @lang\< //text// > @<flatworm--ext-lang>
Set the language the code should be syntax-highlighted for. If "javascript", the
code will be evaluated.
- javascript (will be evaluated)
- script (useful for JavaScript but that should not be evaluated)
- shell
- text
Set the language a [code directive](flatworm--code) should be
syntax-highlighted for. If "javascript", the code will be evaluated.
_heading: @NAV\<text>
_heading: @nav\< //text// > @<flatworm--ext-nav>
Sets the name in the breadcrumbs when not the current node.
_heading: @NOTE\<markdown>
_heading: @note\<// markdown// > @<flatworm--ext-note>
Adds a note to a directive. The //markdown// may contain links. If the directive
already has an @INHERIT extension, that will be used instead and the @NOTE will
be ignored.
_heading: @SRC\<text>
_heading: @src\< //key// > @<flatworm--ext-src>
Calls the configuration ``getSourceUrl(text, VALUE)`` to get a URL which
Calls the configuration ``getSourceUrl(key, VALUE)`` to get a URL which
will be linked to by a link next to the //directive//.
This extended directive function requires an advanced ``config.js`` [[flatworm-config]]
file since it requires a JavaScript function.
_heading: @style\< //text// > @<flatworm--ext-style>
The [Table Style](flatworm--table-style) to use for a table directive.

15
docs.wrm/getting-started.wrm
View File

@ -17,12 +17,12 @@ _subsection: Importing
_heading: Node.js
_code: @lang<script>
_code: node.js require @lang<script>
// CommonJS
const { ethers } = require("ethers");
// ES6 or TypeScript
_code: ES6 or TypeScript @lang<script>
import { ethers } from "ethers";
@ -35,7 +35,14 @@ yourself.
For quick demos or prototyping though, it can be loaded in your
Web Applications from our CDN.
_code: @lang<html>
_code: ES6 in the Browser @lang<html>
<script src="https://cdn.ethers.io/lib/ethers-5.0.esm.min.js"
type="application/javascipt"></script>
_code: ES3 (UMD) in the Browser @lang<html>
<script src="https://cdn.ethers.io/lib/ethers-5.0.umd.min.js"
type="application/javascipt"></script>

14
docs.wrm/migration/ethers-v4.wrm
View File

@ -3,7 +3,7 @@ _section: Migration: From Ethers v4 @<migration-v4>
_subsection: BigNumber
_heading: Namespace
Since [[bignumber]] is used quite frequently, it has been moved to
Since [[BigNumber]] is used quite frequently, it has been moved to
the top level of the umbrella package.
_code: @lang<script>
@ -19,7 +19,7 @@ ethers.BigNumberish
_heading: Creating Instances
The ``bigNumberify`` method was always preferred over the constructor
since it could short-circuit an object instantiation for [[bignumber]
since it could short-circuit an object instantiation for [[BigNumber]
objects (since they are immutable). This has been moved to a static
``from`` class method.
@ -45,11 +45,11 @@ _code: @lang<script>
_subsection: Errors
_heading: Namespace
All errors now belong to the [[logger]] class and the related functions
have been moved to [[logger]] instances, which can include a per-package
All errors now belong to the [[Logger]] class and the related functions
have been moved to [[Logger]] instances, which can include a per-package
version string.
Global error fucntions have been moved [[logger]] class methods.
Global error fucntions have been moved [[Logger]] class methods.
_code: @lang<script>
@ -84,7 +84,7 @@ logger.info(...)
_subsection: Interface
The [[abi-interface]] object has undergone the most dramatic changes.
The [[Interface]] object has undergone the most dramatic changes.
It is no longer a meta-class and now has methods that simplify handling
contract interface operations without the need for object inspection and
@ -124,7 +124,7 @@ interface.encodeEventLog("Transfer", data, topics)
_heading: Inspection
Interrogating properties about a function or event can now (mostly) be
done directly on the [[abi-fragment]] object.
done directly on the [[Fragment]] object.
_code:

175
docs.wrm/quick-start.wrm Normal file
View File

@ -0,0 +1,175 @@
_section: Quick Start
_subsection: Connecting to Ethereum: Metamask
The quickest and easiest way to experiment and begin
developing on Ethereum is to use [[link-metamask]],
which is a browser extension that provider:
- A connection to the Ethereum network
- Holds your private key and can sign thing
_code: Connecting to Metamask
// A Web3Provider wraps a standard Web3 provider, which is
// what Metamask injects into every page you visit as window.ethereum
const provider = new ethers.providers.Web3Provider(window.ethereum)
// The Metamask plugin also allows signing transactions to send ether
// and pay to change state within the blockchain. For this, we need
// the account signer...
const signer = provider.getSigner()
_heading: Querying the Blockchain
Once you have a [[Provider]], you have a read-only connection to the
blockchain, which can be used to query the current state, fetch historic
logs, look up deployed code and so on.
_code: Basic Queries
// <hide>
const provider = ethers.getDefaultProvider();
// </hide>
// Look up the current block number
provider.getBlockNumber()
// Get the balance of an account (by address or ENS name)
provider.getBalance("ethers.eth")
_heading: Writing to the Blockchain
Every write costs ... etc
_code: Sending Ether
// Send 1 ether to an ens name.
const tx = signer.sendTransaction({
to: "ricmoo.firefly.eth",
value: ethers.utils.parseEther("1.0")
});
_subsection: Contracts
_heading: Connecting to a Contract
To connect to an contract...
Explain ABI
Explain meta-class and the aBI
_code: Connecting to a Contract
// The ERC-20 Contract ABI, which is a common contract interface
// for tokens.
const abi = [
// Some simple details about the token
"function namd() view returns (string)",
"function symbol() view returns (string)",
// Get the account balance
"function balanceOf(address) view returns (uint)",
// Send some of your tokens to someone else
"function transfer(address to, uint amount")",
// An event triggered whenever anyone transfers to someone else
"event Transfer(address indexed from, address indexed to, uint amount)"
];
const contract = new ethers.Contract(address, abi, provider);
const contract = new ethers.Contract(address, abi, provider);
_heading: Read-Only Methods
_code: Querying the DAI Contract
// <hide>
// </hide>
const contract = new Contract("dai.tokens.ethers.eth", abi, provider);
contract.name()
//!
contract.symbol()
//!
contract.balanceOf("ricmoo.firefly.eth")
//!
_heading: State Changing Methods
_heading: Listening to Events
_code: Listening to Events
// <hide>
const contract = ...
// </hide>
// Receive an event when ANY transfer occurs
contract.on("Transfer", (from, to, amount, event) => {
console.log(`${ from } sent ${ formatEther(amount) } to ${ to}`);
});
// Receive an event when a specific address receives a token
const filter = contract.filters.Transfer(null, address)
contract.on(filter, (from, to, amount, event) => {
// The to will always be "address"
console.log(`I got ${ formatEther(amount) } from ${ from }.`);
});
_heading: Listing Historic Events
_code: Historic Events by Name
// List all transfers from anyone to anyone in the first XXX
contract.queryFilter("Transfer", 0, XXX)
//!
_code: Filtering Historic Events
// <hide>
const contract = ...
// </hide>
const address = signer.getAddress()
// Filter for all token transfers we've sent
const filterFrom = contract.filter.Transfer(address, null);
// <hide>
filterFrom
// </hide>
//!
// Filter for all token transfers we've received
const filterTo = contract.filter.Transfer(null, address);
// <hide>
filterTo
// </hide>
//!
// List all transfers we've sent between ...
contract.queryFilter(filterFrom, 0, 100000)
//!
// List all transfers we've received in blockhash XXX
contract.queryFilter(filterTo, XXX)
//!
_subsection: Signing Messages

952
docs.wrm/redirects.json Normal file
View File

@ -0,0 +1,952 @@
{
"ethers.js/html/api-advanced.html":
{ "tag": "" },
"ethers.js/html/api-advanced.html#abi-coder":
{ "tag": "" },
"ethers.js/html/api-advanced.html#api-interface":
{ "tag": "interface" },
"ethers.js/html/api-advanced.html#creating-an-instance":
{ "tag": "" },
"ethers.js/html/api-advanced.html#creating-instances":
{ "tag": "" },
"ethers.js/html/api-advanced.html#cryptographic-operations":
{ "tag": "" },
"ethers.js/html/api-advanced.html#deriving-child-and-neutered-nodes":
{ "tag": "hd-wallet--hdnode--methods" },
"ethers.js/html/api-advanced.html#descriptions":
{ "tag": "" },
"ethers.js/html/api-advanced.html#hdnode":
{ "tag": "hd-wallet" },
"ethers.js/html/api-advanced.html#interface":
{ "tag": "abi-interface" },
"ethers.js/html/api-advanced.html#low-level-api":
{ "tag": "" },
"ethers.js/html/api-advanced.html#object-test-functions":
{ "tag": "" },
"ethers.js/html/api-advanced.html#parsing-objects":
{ "tag": "" },
"ethers.js/html/api-advanced.html#prototype":
{ "tag": "" },
"ethers.js/html/api-advanced.html#provider-sub-classing":
{ "tag": "" },
"ethers.js/html/api-advanced.html#recursive-length-prefixed-encoding-rlp":
{ "tag": "rlp" },
"ethers.js/html/api-advanced.html#signing-key":
{ "tag": "utils-signingkey" },
"ethers.js/html/api-advanced.html#static-methods":
{ "tag": "" },
"ethers.js/html/api-advanced.html#static-properties":
{ "tag": "" },
"ethers.js/html/api-contract.html":
{ "tag": "contract" },
"ethers.js/html/api-contract.html#api-contract":
{ "tag": "contract" },
"ethers.js/html/api-contract.html#application-binary-interface-abi":
{ "tag": "" },
"ethers.js/html/api-contract.html#bytes":
{ "tag": "" },
"ethers.js/html/api-contract.html#configuring-events":
{ "tag": "" },
"ethers.js/html/api-contract.html#connecting":
{ "tag": "" },
"ethers.js/html/api-contract.html#connecting-to-a-contract":
{ "tag": "" },
"ethers.js/html/api-contract.html#connecting-to-existing-contracts":
{ "tag": "" },
"ethers.js/html/api-contract.html#contract-abi":
{ "tag": "" },
"ethers.js/html/api-contract.html#contract-event-filters":
{ "tag": "" },
"ethers.js/html/api-contract.html#contract-filter":
{ "tag": "" },
"ethers.js/html/api-contract.html#contract-metaclass":
{ "tag": "" },
"ethers.js/html/api-contract.html#contract-methods":
{ "tag": "" },
"ethers.js/html/api-contract.html#contracts":
{ "tag": "" },
"ethers.js/html/api-contract.html#creating-a-contract-factory":
{ "tag": "" },
"ethers.js/html/api-contract.html#deploying-a-contract":
{ "tag": "" },
"ethers.js/html/api-contract.html#deployment":
{ "tag": "" },
"ethers.js/html/api-contract.html#event-emitter":
{ "tag": "" },
"ethers.js/html/api-contract.html#event-names":
{ "tag": "" },
"ethers.js/html/api-contract.html#event-object":
{ "tag": "" },
"ethers.js/html/api-contract.html#filtering-events":
{ "tag": "" },
"ethers.js/html/api-contract.html#integers":
{ "tag": "" },
"ethers.js/html/api-contract.html#meta-class-properties":
{ "tag": "" },
"ethers.js/html/api-contract.html#overrides":
{ "tag": "" },
"ethers.js/html/api-contract.html#prototype":
{ "tag": "" },
"ethers.js/html/api-contract.html#providers-vs-signers":
{ "tag": "" },
"ethers.js/html/api-contract.html#strings":
{ "tag": "" },
"ethers.js/html/api-contract.html#structs":
{ "tag": "" },
"ethers.js/html/api-contract.html#types":
{ "tag": "" },
"ethers.js/html/api-contract.html#waiting-for-deployment":
{ "tag": "" },
"ethers.js/html/api-providers.html":
{ "tag": "providers" },
"ethers.js/html/api-providers.html#account":
{ "tag": "provider--account-methods" },
"ethers.js/html/api-providers.html#api-provider":
{ "tag": "providers" },
"ethers.js/html/api-providers.html#block-responses":
{ "tag": "provider--block-methods" },
"ethers.js/html/api-providers.html#block-tag":
{ "tag": "provider-blocktag" },
"ethers.js/html/api-providers.html#blockchain-status":
{ "tag": "provider--network-status-methods" },
"ethers.js/html/api-providers.html#blockresponse":
{ "tag": "" },
"ethers.js/html/api-providers.html#blocktag":
{ "tag": "provider-blocktag" },
"ethers.js/html/api-providers.html#connecting-to-ethereum":
{ "tag": "get-default-provider" },
"ethers.js/html/api-providers.html#contract-execution":
{ "tag": "" },
"ethers.js/html/api-providers.html#contract-state":
{ "tag": "" },
"ethers.js/html/api-providers.html#ethereum-naming-service":
{ "tag": "" },
"ethers.js/html/api-providers.html#etherscan":
{ "tag": "api-providers--etehrscanprovider" },
"ethers.js/html/api-providers.html#etherscanprovider-inherits-from-provider":
{ "tag": "" },
"ethers.js/html/api-providers.html#event-types":
{ "tag": "" },
"ethers.js/html/api-providers.html#events":
{ "tag": "" },
"ethers.js/html/api-providers.html#fallbackprovider-inherits-from-provider":
{ "tag": "" },
"ethers.js/html/api-providers.html#filter":
{ "tag": "" },
"ethers.js/html/api-providers.html#filters":
{ "tag": "" },
"ethers.js/html/api-providers.html#infuraprovider-inherits-from-jsonrpcprovider":
{ "tag": "" },
"ethers.js/html/api-providers.html#ipcprovider-inherits-from-jsonrpcprovider":
{ "tag": "" },
"ethers.js/html/api-providers.html#jsonrpcprovider":
{ "tag": "" },
"ethers.js/html/api-providers.html#jsonrpcprovider-inherits-from-provider":
{ "tag": "" },
"ethers.js/html/api-providers.html#jsonrpcsigner":
{ "tag": "" },
"ethers.js/html/api-providers.html#log":
{ "tag": "" },
"ethers.js/html/api-providers.html#network":
{ "tag": "" },
"ethers.js/html/api-providers.html#objects-and-types":
{ "tag": "" },
"ethers.js/html/api-providers.html#properties":
{ "tag": "" },
"ethers.js/html/api-providers.html#provider":
{ "tag": "" },
"ethers.js/html/api-providers.html#provider-connect":
{ "tag": "" },
"ethers.js/html/api-providers.html#provider-etherscan-extra":
{ "tag": "" },
"ethers.js/html/api-providers.html#provider-etherscan-properties":
{ "tag": "" },
"ethers.js/html/api-providers.html#provider-fallback-properties":
{ "tag": "" },
"ethers.js/html/api-providers.html#provider-infura-properties":
{ "tag": "" },
"ethers.js/html/api-providers.html#provider-ipc-properties":
{ "tag": "" },
"ethers.js/html/api-providers.html#provider-jsonrpc-extra":
{ "tag": "" },
"ethers.js/html/api-providers.html#provider-jsonrpc-properties":
{ "tag": "" },
"ethers.js/html/api-providers.html#provider-specific-extra-api-calls":
{ "tag": "" },
"ethers.js/html/api-providers.html#provider-web3-properties":
{ "tag": "" },
"ethers.js/html/api-providers.html#providers":
{ "tag": "" },
"ethers.js/html/api-providers.html#signer-jsonrpc":
{ "tag": "" },
"ethers.js/html/api-providers.html#transaction-receipt":
{ "tag": "" },
"ethers.js/html/api-providers.html#transaction-receipts":
{ "tag": "" },
"ethers.js/html/api-providers.html#transaction-request":
{ "tag": "" },
"ethers.js/html/api-providers.html#transaction-requests":
{ "tag": "" },
"ethers.js/html/api-providers.html#transaction-response":
{ "tag": "" },
"ethers.js/html/api-providers.html#waitfortransaction":
{ "tag": "" },
"ethers.js/html/api-providers.html#waiting-for-transactions":
{ "tag": "" },
"ethers.js/html/api-providers.html#web3provider-inherits-from-jsonrpcprovider":
{ "tag": "" },
"ethers.js/html/api-utils.html":
{ "tag": "" },
"ethers.js/html/api-utils.html#addresses":
{ "tag": "addresses" },
"ethers.js/html/api-utils.html#arrayish":
{ "tag": "bytes" },
"ethers.js/html/api-utils.html#big-numbers":
{ "tag": "bignumber" },
"ethers.js/html/api-utils.html#bignumber":
{ "tag": "bignumber" },
"ethers.js/html/api-utils.html#bytes32-strings":
{ "tag": "bytes32-string" },
"ethers.js/html/api-utils.html#bytes32string":
{ "tag": "bytes32-string" },
"ethers.js/html/api-utils.html#constants":
{ "tag": "constants" },
"ethers.js/html/api-utils.html#creating-instances":
{ "tag": "" },
"ethers.js/html/api-utils.html#cryptographic-functions":
{ "tag": "hashing-algorithms--cryptographic-hash-functions" },
"ethers.js/html/api-utils.html#elliptic-curve":
{ "tag": "" },
"ethers.js/html/api-utils.html#ether-strings-and-wei":
{ "tag": "" },
"ethers.js/html/api-utils.html#formatether":
{ "tag": "utils-formatunits" },
"ethers.js/html/api-utils.html#hash-function-helpers":
{ "tag": "" },
"ethers.js/html/api-utils.html#hash-functions":
{ "tag": "hashing-algorithms--cryptographic-hash-functions" },
"ethers.js/html/api-utils.html#hex-strings":
{ "tag": "hexstring" },
"ethers.js/html/api-utils.html#hexstring":
{ "tag": "hexstring" },
"ethers.js/html/api-utils.html#key-derivation":
{ "tag": "" },
"ethers.js/html/api-utils.html#namehash":
{ "tag": "utils-namehash" },
"ethers.js/html/api-utils.html#parseether":
{ "tag": "utils-parseunits" },
"ethers.js/html/api-utils.html#random":
{ "tag": "utils-randombytes" },
"ethers.js/html/api-utils.html#signature":
{ "tag": "signature" },
"ethers.js/html/api-utils.html#signatures":
{ "tag": "signature" },
"ethers.js/html/api-utils.html#solidity":
{ "tag": "" },
"ethers.js/html/api-utils.html#transactions":
{ "tag": "" },
"ethers.js/html/api-utils.html#utf-8-strings":
{ "tag": "utf8-string" },
"ethers.js/html/api-utils.html#utf8-strings":
{ "tag": "utf8-string" },
"ethers.js/html/api-utils.html#utilities":
{ "tag": "" },
"ethers.js/html/api-utils.html#utils-getaddress":
{ "tag": "utils-getAddress" },
"ethers.js/html/api-utils.html#web":
{ "tag": "web-utilities" },
"ethers.js/html/api-wallet.html":
{ "tag": "wallet" },
"ethers.js/html/api-wallet.html#blockchain-operations":
{ "tag": "signer-blockchain" },
"ethers.js/html/api-wallet.html#creating-instances":
{ "tag": "wallet" },
"ethers.js/html/api-wallet.html#encrypted-json-wallets":
{ "tag": "" },
"ethers.js/html/api-wallet.html#fromencryptedjson":
{ "tag": "wallet-fromencryptedjson" },
"ethers.js/html/api-wallet.html#prototype":
{ "tag": "signers--wallet--properties" },
"ethers.js/html/api-wallet.html#sendtransaction":
{ "tag": "signer-sendtransaction" },
"ethers.js/html/api-wallet.html#signer":
{ "tag": "signer" },
"ethers.js/html/api-wallet.html#signer-api":
{ "tag": "signer" },
"ethers.js/html/api-wallet.html#signing":
{ "tag": "signers--signer--signing" },
"ethers.js/html/api-wallet.html#wallet":
{ "tag": "wallet" },
"ethers.js/html/api-wallet.html#wallet-connect":
{ "tag": "" },
"ethers.js/html/api-wallet.html#wallets-and-signers":
{ "tag": "" },
"ethers.js/html/api.html":
{ "tag": "" },
"ethers.js/html/api.html#api":
{ "tag": "" },
"ethers.js/html/api.html#application-programming-interface-api":
{ "tag": "" },
"ethers.js/html/cookbook-accounts.html":
{ "tag": "" },
"ethers.js/html/cookbook-accounts.html#access-funds-in-a-mnemonic-phrase-wallet":
{ "tag": "" },
"ethers.js/html/cookbook-accounts.html#accounts":
{ "tag": "" },
"ethers.js/html/cookbook-accounts.html#coalesce-jaxx-wallets":
{ "tag": "" },
"ethers.js/html/cookbook-accounts.html#dump-all-json-wallet-balances-in-current-directory":
{ "tag": "" },
"ethers.js/html/cookbook-accounts.html#get-transaction-history":
{ "tag": "" },
"ethers.js/html/cookbook-accounts.html#random-mnemonic":
{ "tag": "" },
"ethers.js/html/cookbook-accounts.html#sweep-an-account-into-another":
{ "tag": "" },
"ethers.js/html/cookbook-contracts.html":
{ "tag": "" },
"ethers.js/html/cookbook-contracts.html#contracts":
{ "tag": "" },
"ethers.js/html/cookbook-contracts.html#economic-incentives-and-economic-value":
{ "tag": "" },
"ethers.js/html/cookbook-contracts.html#return-a-value-from-a-state-changing-method":
{ "tag": "" },
"ethers.js/html/cookbook-providers.html":
{ "tag": "" },
"ethers.js/html/cookbook-providers.html#custom-provider":
{ "tag": "" },
"ethers.js/html/cookbook-providers.html#metamask":
{ "tag": "" },
"ethers.js/html/cookbook-providers.html#providers":
{ "tag": "" },
"ethers.js/html/cookbook-providers.html#testrpc-ganache":
{ "tag": "" },
"ethers.js/html/cookbook-react.html":
{ "tag": "" },
"ethers.js/html/cookbook-react.html#other-notes":
{ "tag": "" },
"ethers.js/html/cookbook-react.html#react-native":
{ "tag": "" },
"ethers.js/html/cookbook-react.html#shims":
{ "tag": "" },
"ethers.js/html/cookbook-react.html#wordlists":
{ "tag": "" },
"ethers.js/html/cookbook-signing.html":
{ "tag": "" },
"ethers.js/html/cookbook-signing.html#signing-a-digest-hash":
{ "tag": "" },
"ethers.js/html/cookbook-signing.html#signing-a-string-message":
{ "tag": "" },
"ethers.js/html/cookbook-signing.html#signing-messages":
{ "tag": "" },
"ethers.js/html/cookbook-testing.html":
{ "tag": "" },
"ethers.js/html/cookbook-testing.html#contract-events":
{ "tag": "" },
"ethers.js/html/cookbook-testing.html#testing":
{ "tag": "" },
"ethers.js/html/cookbook-testing.html#using-multiple-accounts":
{ "tag": "" },
"ethers.js/html/cookbook.html":
{ "tag": "" },
"ethers.js/html/cookbook.html#cookbook":
{ "tag": "" },
"ethers.js/html/getting-started.html":
{ "tag": "" },
"ethers.js/html/getting-started.html#getting-started":
{ "tag": "" },
"ethers.js/html/getting-started.html#importing":
{ "tag": "" },
"ethers.js/html/getting-started.html#including-in-web-applications":
{ "tag": "" },
"ethers.js/html/getting-started.html#installing-in-node-js":
{ "tag": "" },
"ethers.js/html/index.html":
{ "tag": "" },
"ethers.js/html/index.html#features":
{ "tag": "" },
"ethers.js/html/index.html#legacy-documentation":
{ "tag": "" },
"ethers.js/html/index.html#what-is-ethers-js":
{ "tag": "" },
"ethers.js/html/migration.html":
{ "tag": "" },
"ethers.js/html/migration.html#big-number":
{ "tag": "" },
"ethers.js/html/migration.html#constants":
{ "tag": "" },
"ethers.js/html/migration.html#custom-signer":
{ "tag": "" },
"ethers.js/html/migration.html#default-provider":
{ "tag": "" },
"ethers.js/html/migration.html#deploying-contracts":
{ "tag": "" },
"ethers.js/html/migration.html#encrypted-wallets":
{ "tag": "" },
"ethers.js/html/migration.html#events":
{ "tag": "" },
"ethers.js/html/migration.html#fetching-json":
{ "tag": "" },
"ethers.js/html/migration.html#interfaces":
{ "tag": "" },
"ethers.js/html/migration.html#jsonrpcprovider":
{ "tag": "" },
"ethers.js/html/migration.html#migrating-from-ethers-v3-to-ethers-v4":
{ "tag": "" },
"ethers.js/html/migration.html#migrating-from-web3-to-ethers-v4":
{ "tag": "" },
"ethers.js/html/migration.html#migration-guides":
{ "tag": "" },
"ethers.js/html/migration.html#networks":
{ "tag": "" },
"ethers.js/html/migration.html#parsing-transactions":
{ "tag": "" },
"ethers.js/html/migration.html#verifying-messages":
{ "tag": "" },
"ethers.js/html/migration.html#waiting-for-transactions":
{ "tag": "" },
"ethers.js/html/notes.html":
{ "tag": "" },
"ethers.js/html/notes.html#checksum-address":
{ "tag": "" },
"ethers.js/html/notes.html#contributing":
{ "tag": "" },
"ethers.js/html/notes.html#icap-address":
{ "tag": "" },
"ethers.js/html/notes.html#ieee754":
{ "tag": "" },
"ethers.js/html/notes.html#memory-hard-brute-force-encrpyting":
{ "tag": "" },
"ethers.js/html/notes.html#notes":
{ "tag": "" },
"ethers.js/html/notes.html#promise":
{ "tag": "" },
"ethers.js/html/notes.html#promises":
{ "tag": "" },
"ethers.js/html/notes.html#responsible-disclosure":
{ "tag": "" },
"ethers.js/html/notes.html#security":
{ "tag": "" },
"ethers.js/html/notes.html#supported-platforms":
{ "tag": "" },
"ethers.js/html/notes.html#the-github-and-npm-package":
{ "tag": "" },
"ethers.js/html/notes.html#why-can-t-i-just-use-numbers":
{ "tag": "" },
"ethers.js/html/testing.html":
{ "tag": "" },
"ethers.js/html/testing.html#testing":
{ "tag": "" },
"ethers.js/v3.0/examples/splitter/index.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/examples/splitter/index.html" },
"ethers.js/v3.0/examples/tool/index.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/examples/tool/index.html" },
"ethers.js/v3.0/examples/wallet/index.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/examples/wallet/index.html" },
"ethers.js/v3.0/html/api-advanced.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/api-advanced.html" },
"ethers.js/v3.0/html/api-contract.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/api-contract.html" },
"ethers.js/v3.0/html/api-providers.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/api-providers.html" },
"ethers.js/v3.0/html/api-utils.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/api-utils.html" },
"ethers.js/v3.0/html/api-wallet.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/api-wallet.html" },
"ethers.js/v3.0/html/api.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/api.html" },
"ethers.js/v3.0/html/cookbook.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/cookbook.html" },
"ethers.js/v3.0/html/genindex.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/genindex.html" },
"ethers.js/v3.0/html/getting-started.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/getting-started.html" },
"ethers.js/v3.0/html/index.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/index.html" },
"ethers.js/v3.0/html/notes.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/notes.html" },
"ethers.js/v3.0/html/search.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/search.html" },
"ethers.js/v3.0/html/testing.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/html/testing.html" },
"ethers.js/v3.0/index.html":
{ "redirect": "https://docs-legacy.ethers.io/v3/index.html" },
"ethers.js/v5-beta/about-ethereum.html":
{ "tag": "" },
"ethers.js/v5-beta/about-ethereum.html#ethereum-basics":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#abi-coder":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#api-interface":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#creating-an-instance":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#creating-instances":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#cryptographic-operations":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#deriving-child-and-neutered-nodes":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#descriptions":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#hdnode":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#interface":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#low-level-api":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#object-test-functions":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#parsing-objects":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#prototype":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#provider-sub-classing":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#recursive-length-prefixed-encoding-rlp":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#signing-key":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#static-methods":
{ "tag": "" },
"ethers.js/v5-beta/api-advanced.html#static-properties":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#api-contract":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#application-binary-interface-abi":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#bytes":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#configuring-events":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#connecting":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#connecting-to-a-contract":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#connecting-to-existing-contracts":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#contract-abi":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#contract-event-filters":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#contract-filter":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#contract-metaclass":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#contract-methods":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#contracts":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#creating-a-contract-factory":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#deploying-a-contract":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#deployment":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#event-emitter":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#event-names":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#event-object":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#filtering-events":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#integers":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#meta-class-properties":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#overrides":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#prototype":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#providers-vs-signers":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#strings":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#structs":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#types":
{ "tag": "" },
"ethers.js/v5-beta/api-contract.html#waiting-for-deployment":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#account":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#api-provider":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#block-responses":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#block-tag":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#blockchain-status":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#blockresponse":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#blocktag":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#connecting-to-ethereum":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#contract-execution":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#contract-state":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#ethereum-naming-service":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#etherscanprovider-inherits-from-provider":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#event-types":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#events":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#fallbackprovider-inherits-from-provider":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#filter":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#filters":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#infuraprovider-inherits-from-jsonrpcprovider":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#ipcprovider-inherits-from-jsonrpcprovider":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#jsonrpcprovider-inherits-from-provider":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#jsonrpcsigner":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#log":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#network":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#nodesmithprovider-inherits-from-jsonrpcprovider":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#objects-and-types":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#properties":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#provider":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#provider-connect":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#provider-jsonrpc":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#provider-specific-properties-and-methods":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#providers":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#signer-jsonrpc":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#signer-uncheckedjsonrpc":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#transaction-receipt":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#transaction-receipts":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#transaction-request":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#transaction-requests":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#transaction-response":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#uncheckedjsonrpcsigner":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#waitfortransaction":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#waiting-for-transactions":
{ "tag": "" },
"ethers.js/v5-beta/api-providers.html#web3provider-inherits-from-jsonrpcprovider":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#addresses":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#arrayish":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#big-numbers":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#bignumber":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#bytes32-strings":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#bytes32string":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#constants":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#creating-instances":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#cryptographic-functions":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#elliptic-curve":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#ether-strings-and-wei":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#formatether":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#hash-function-helpers":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#hash-functions":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#hex-strings":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#hexstring":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#key-derivation":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#namehash":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#parseether":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#random":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#signature":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#signatures":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#solidity":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#transactions":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#utf-8-strings":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#utf8-strings":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#utilities":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#utils-getaddress":
{ "tag": "" },
"ethers.js/v5-beta/api-utils.html#web":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#blockchain-operations":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#creating-instances":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#encrypted-json-wallets":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#fromencryptedjson":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#prototype":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#sendtransaction":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#signer":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#signer-api":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#signing":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#void-signer":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#wallet":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#wallet-connect":
{ "tag": "" },
"ethers.js/v5-beta/api-wallet.html#wallets-and-signers":
{ "tag": "" },
"ethers.js/v5-beta/api.html":
{ "tag": "" },
"ethers.js/v5-beta/api.html#api":
{ "tag": "" },
"ethers.js/v5-beta/api.html#application-programming-interface-api":
{ "tag": "" },
"ethers.js/v5-beta/basics.html":
{ "tag": "" },
"ethers.js/v5-beta/basics.html#ethereum-basics":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-accounts.html":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-accounts.html#access-funds-in-a-mnemonic-phrase-wallet":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-accounts.html#accounts":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-accounts.html#coalesce-jaxx-wallets":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-accounts.html#dump-all-json-wallet-balances-in-current-directory":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-accounts.html#get-transaction-history":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-accounts.html#random-mnemonic":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-accounts.html#sweep-an-account-into-another":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-contracts.html":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-contracts.html#contracts":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-contracts.html#economic-incentives-and-economic-value":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-contracts.html#return-a-value-from-a-state-changing-method":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-providers.html":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-providers.html#custom-provider":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-providers.html#metamask":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-providers.html#providers":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-providers.html#testrpc-ganache":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-react.html":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-react.html#other-notes":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-react.html#react-native":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-react.html#shims":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-react.html#wordlists":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-signing.html":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-signing.html#signing-a-digest-hash":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-signing.html#signing-a-string-message":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-signing.html#signing-messages":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-testing.html":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-testing.html#contract-events":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-testing.html#testing":
{ "tag": "" },
"ethers.js/v5-beta/cookbook-testing.html#using-multiple-accounts":
{ "tag": "" },
"ethers.js/v5-beta/cookbook.html":
{ "tag": "" },
"ethers.js/v5-beta/cookbook.html#cookbook":
{ "tag": "" },
"ethers.js/v5-beta/getting-started.html":
{ "tag": "" },
"ethers.js/v5-beta/getting-started.html#getting-started":
{ "tag": "" },
"ethers.js/v5-beta/getting-started.html#importing":
{ "tag": "" },
"ethers.js/v5-beta/getting-started.html#including-in-web-applications":
{ "tag": "" },
"ethers.js/v5-beta/getting-started.html#installing-in-node-js":
{ "tag": "" },
"ethers.js/v5-beta/index.html":
{ "tag": "" },
"ethers.js/v5-beta/index.html#features":
{ "tag": "" },
"ethers.js/v5-beta/index.html#legacy-documentation":
{ "tag": "" },
"ethers.js/v5-beta/index.html#what-is-ethers-js":
{ "tag": "" },
"ethers.js/v5-beta/migration.html":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#big-number":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#constants":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#custom-signer":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#default-provider":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#deploying-contracts":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#encrypted-wallets":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#events":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#fetching-json":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#interfaces":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#jsonrpcprovider":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#migrating-from-ethers-v3-to-ethers-v4":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#migrating-from-web3-to-ethers-v4":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#migration-guides":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#networks":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#parsing-transactions":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#verifying-messages":
{ "tag": "" },
"ethers.js/v5-beta/migration.html#waiting-for-transactions":
{ "tag": "" },
"ethers.js/v5-beta/notes.html":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#checksum-address":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#contributing":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#icap-address":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#ieee754":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#memory-hard-brute-force-encrpyting":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#notes":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#promise":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#promises":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#responsible-disclosure":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#security":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#supported-platforms":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#the-github-and-npm-package":
{ "tag": "" },
"ethers.js/v5-beta/notes.html#why-can-t-i-just-use-numbers":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html#addresses":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html#aion-network":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html#api":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html#avm-contracts":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html#differences-from-ethereum":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html#elliptic-curve-cryptography":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html#fvm-contracts":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html#hashing":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html#hashing-algorithm":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html#serializing-transactions":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html#transactions":
{ "tag": "" },
"ethers.js/v5-beta/platforms-aion.html#wallet":
{ "tag": "" },
"ethers.js/v5-beta/platforms-ganache.html":
{ "tag": "" },
"ethers.js/v5-beta/platforms-ganache.html#ganache":
{ "tag": "" },
"ethers.js/v5-beta/platforms-react.html":
{ "tag": "" },
"ethers.js/v5-beta/platforms-react.html#react-native":
{ "tag": "" },
"ethers.js/v5-beta/platforms-truffle.html":
{ "tag": "" },
"ethers.js/v5-beta/platforms-truffle.html#truffle":
{ "tag": "" },
"ethers.js/v5-beta/platforms.html":
{ "tag": "" },
"ethers.js/v5-beta/platforms.html#other-platform":
{ "tag": "" },
"ethers.js/v5-beta/testing.html":
{ "tag": "" },
"ethers.js/v5-beta/testing.html#testing":
{ "tag": "" }
}