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

Merge pull request #4 from ethers-io/ethers-v5-beta

Browse Source 
Ethers v5 beta
This commit is contained in:
Ronan Sandford 2020-01-13 08:44:01 +05:30 committed by GitHub
commit 792afabdc0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1397 changed files with 33474 additions and 8862 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

148
.circleci/config.yml Normal file
View File

@ -0,0 +1,148 @@
version: 2.1
executors:
machine_executor:
machine: true
working_directory: ~/repo
commands:
build-and-test:
parameters:
node-version:
type: string
default: "10.16.3"
test-script:
type: string
default: "test-node"
upgrade-chrome:
type: string
default: ""
steps:
- checkout
- when:
condition: << parameters.upgrade-chrome >>
steps:
- run:
name: Upgrade chrome
command: |
sudo apt-get purge chromium-browser
sudo apt-get update
sudo apt-get install -y libappindicator1 fonts-liberation
wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
sudo dpkg -i google-chrome*.deb
google-chrome --version
- run:
name: Update gcc version
command: |
sudo add-apt-repository ppa:ubuntu-toolchain-r/test
sudo apt update
sudo apt install gcc-6
sudo apt install g++-6
sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-6 60 --slave /usr/bin/g++ g++ /usr/bin/g++-6
- run:
name: Prepare to run parity
command: |
mkdir -p /tmp/parity/keys
cp -r admin/test-parity/parity-keys /tmp/parity/keys/DevelopmentChain
cp admin/test-parity/parity-dev.* /tmp/parity
chmod -R 777 /tmp/parity
ls -la /tmp/parity
- run:
name: Starting Parity
command: |
docker run -d \
-p 8545:8545 \
-p 8546:8546 \
-p 30303:30303 \
-p 30303:30303/udp \
--name parity \
-v /tmp/parity:/home/parity/.local/share/io.parity.ethereum parity/parity:v2.4.8-stable \
--chain /home/parity/.local/share/io.parity.ethereum/parity-dev.json \
--unlock=0x7454a8F5a7c7555d79B172C89D20E1f4e4CC226C \
--password /home/parity/.local/share/io.parity.ethereum/parity-dev.pwds \
--min-gas-price 1000000000 \
--jsonrpc-interface all
- run:
name: Waiting for Parity to be ready
command: |
for i in `seq 1 20`;
do
nc -z localhost 8545 && echo Success && exit 0
echo -n .
sleep 2
done
docker ps -a
docker logs parity
echo Failed waiting for Parity && exit 1
- run:
name: Run << parameters.test-script >> with node version << parameters.node-version >>
command: |
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh" # This loads nvm
[ -s "$NVM_DIR/bash_completion" ] && \. "$NVM_DIR/bash_completion"
nvm install << parameters.node-version >>
node -v
npm -v
gcc --version
npm ci
npm run bootstrap
npm run << parameters.test-script >>
jobs:
node-v8:
description: "test with node version 8"
executor: machine_executor
steps:
- build-and-test:
node-version: "8.16.1"
test-script: "test-node"
node-v10:
description: "test with node version 10"
executor: machine_executor
steps:
- build-and-test:
node-version: "10.16.3"
test-script: "test-node"
node-v12:
description: "test with node version 12"
executor: machine_executor
steps:
- build-and-test:
node-version: "12.13.1"
test-script: "test-node"
browser-esm:
description: "test browser with es6 module"
executor: machine_executor
steps:
- build-and-test:
node-version: "12.13.1"
test-script: "test-browser-esm"
upgrade-chrome: "true"
browser-umd:
description: "test browser with es3 module"
executor: machine_executor
steps:
- build-and-test:
node-version: "12.13.1"
test-script: "test-browser-umd"
workflows:
version: 2
all:
jobs:
- node-v8
- node-v10
- node-v12
- browser-esm
- browser-umd

98
CHANGELOG.md
View File

@ -3,6 +3,104 @@ Changelog
This change log is managed by `scripts/cmds/update-versions` but may be manually updated.
ethers/v5.0.0-beta.167 (2020-01-11 04:16)
-----------------------------------------
- Fixed testcases for provider changes. ([90ed07c](https://github.com/ethers-io/ethers.js/commit/90ed07c74e7230ea0f02288b140d497d8b9779e0))
- Add support for legacy flat signatures with recid instead of normalized v. ([245cd0e](https://github.com/ethers-io/ethers.js/commit/245cd0e48e07eef35f5bf45ee7fe5ed5ef31338a))
- Fix TransactionResponse to have chainId instead of legacy networkId. ([#700](https://github.com/ethers-io/ethers.js/issues/700); [72b3bc9](https://github.com/ethers-io/ethers.js/commit/72b3bc9909074893038c768f3da1564ed96a6a20))
- Fixed splitSignature computing wrong v for BytesLike. ([#700](https://github.com/ethers-io/ethers.js/issues/700); [4151c0e](https://github.com/ethers-io/ethers.js/commit/4151c0eacd22287e2369a8656ffa00359db6f84b))
- Added dist files for hardware-wallets. ([c846649](https://github.com/ethers-io/ethers.js/commit/c84664953d2f50ee0d704a8aa18fe6c08668dabb))
- Browser support (with dist files) for Ledger. ([6f7fbf3](https://github.com/ethers-io/ethers.js/commit/6f7fbf3858c82417933a5e5595a919c0ec0487c7))
ethers/v5.0.0-beta.166 (2020-01-10 03:09)
-----------------------------------------
- Relaxed joinSignature API to allow SignauteLike. ([602e6a8](https://github.com/ethers-io/ethers.js/commit/602e6a8973480299843a0158f75451a2c6aac749))
- Initial code drop of new hardware wallet package. ([2e8f5ca](https://github.com/ethers-io/ethers.js/commit/2e8f5ca7ed498261079da75713b18f3370dfd236))
- Added more docs. ([381a72d](https://github.com/ethers-io/ethers.js/commit/381a72ddaa7fb59ef2ded84d228296d693df05c3))
ethers/v5.0.0-beta.165 (2020-01-09 03:31)
-----------------------------------------
- Fixed require resolution for CLI scripts. ([c04f9a7](https://github.com/ethers-io/ethers.js/commit/c04f9a7fff727bb04a4aa3a0fa05fd5cd8e795a6))
- Added new URLs for default ETC (and ETC testnets) providers. ([#351](https://github.com/ethers-io/ethers.js/issues/351); [3c184ac](https://github.com/ethers-io/ethers.js/commit/3c184ace21aafbb27f4d44cce1bb738af899d59f))
ethers/v5.0.0-beta.164 (2020-01-07 19:57)
-----------------------------------------
- Use better Description typing. ([2d5492c](https://github.com/ethers-io/ethers.js/commit/2d5492cd2ee722c818c249244af7b5bea05d67b0))
- Better property access on ABI decoded results. ([#698](https://github.com/ethers-io/ethers.js/issues/698); [13f50ab](https://github.com/ethers-io/ethers.js/commit/13f50abd847f7ddcc7e54c102da54e2d23b86fae))
- Better typing support for Description. ([d0f4642](https://github.com/ethers-io/ethers.js/commit/d0f4642f6d2c9f5119f1910a0082894c60e81191))
- Fixed resolveName when name is an address with an invalid checksum. ([#694](https://github.com/ethers-io/ethers.js/issues/694); [1e72fc7](https://github.com/ethers-io/ethers.js/commit/1e72fc7d6f7c3be4410dbdcfbab9a0463ceb52bd))
ethers/v5.0.0-beta.163 (2020-01-06 18:57)
-----------------------------------------
- Added function to generate CREATE2 addresses. ([#697](https://github.com/ethers-io/ethers.js/issues/697); [eb26a6d](https://github.com/ethers-io/ethers.js/commit/eb26a6d95022a241c44f859e7b2f29646afb4914))
- Force constructor name to be null (instead of undefined). ([a648f2b](https://github.com/ethers-io/ethers.js/commit/a648f2bd1e5e52a3662896f04fe7025884866972))
- Added documentation uploading script. ([e593aba](https://github.com/ethers-io/ethers.js/commit/e593aba2946c98820b0c2edf9c5dab6cb30c7402))
- Added Czech wordlist to default wordlists export. ([#691](https://github.com/ethers-io/ethers.js/issues/691); [5724fa5](https://github.com/ethers-io/ethers.js/commit/5724fa5d9c6fe73f14ec8bdea1f7226a222537ef))
- Added Czech BIP-39 wordlist. ([#691](https://github.com/ethers-io/ethers.js/issues/691); [f54f06b](https://github.com/ethers-io/ethers.js/commit/f54f06b5c8092997fd3c9055d69a3e0796ce44f3))
- Updated README. ([e809ead](https://github.com/ethers-io/ethers.js/commit/e809eadf8d608cd8c8a78c08a2e3547dd09156cf))
- Updating docs. ([184c459](https://github.com/ethers-io/ethers.js/commit/184c459fab0d089a8a879584b72e5eb3560b33ce))
- Merge branch 'yuetloo-ethers-v5-beta' into ethers-v5-beta ([06cafe3](https://github.com/ethers-io/ethers.js/commit/06cafe3437ef129b47f5f9c02f4759f2c4854d3c))
- Add circleci and parity test files ([fdf0980](https://github.com/ethers-io/ethers.js/commit/fdf0980663ffead0faf3e9b7b233b22ca1574e21))
- Fixed typo in package test dist scripts. ([9c78c7f](https://github.com/ethers-io/ethers.js/commit/9c78c7fee69d07733048d898d58205ae7f5c82d7))
ethers/v5.0.0-beta.162 (2019-11-25 0:02)
----------------------------------------
- Update elliptic package to protect from Minerva timing attack. ([#666](https://github.com/ethers-io/ethers.js/issues/666); [cf036e1](https://github.com/ethers-io/ethers.js/commit/cf036e1ffad3340fcf1c7559d0032493ccc08e6e))
- Browser and node testing works again. ([4470477](https://github.com/ethers-io/ethers.js/commit/4470477d7fd3031f2f3a1fbd9c538468c33c7350))
ethers/v5.0.0-beta.161 (2019-11-23 21:43)
-----------------------------------------
- Updated dist files (sorted package.json to reduce package version change chatter). ([f308ba3](https://github.com/ethers-io/ethers.js/commit/f308ba3540ed0d282d099456d0369873ad9596b0))
- Stubs for adding throttle support. ([2f0e679](https://github.com/ethers-io/ethers.js/commit/2f0e679f0bc81bf901cf60a79e50f9715cddec5a))
- Refactor wordlists. ([abab9f6](https://github.com/ethers-io/ethers.js/commit/abab9f6aa27d1870d1053e7caa951408b86c454d))
- Browser testcases work again. ([c11c2e2](https://github.com/ethers-io/ethers.js/commit/c11c2e2e3376a6764f07ed443245823f2792b8cc))
- Added dist files for non-English wordlists. ([3d75c52](https://github.com/ethers-io/ethers.js/commit/3d75c52dac668af5eeede3e7764dadd3055a0707))
- Sync GitHub issue cache. ([29f0e9d](https://github.com/ethers-io/ethers.js/commit/29f0e9dd627a7b4b7f772300497f27718c9ecc7b))
ethers/v5.0.0-beta.160 (2019-11-20 18:36)
-----------------------------------------
- Updated API in testcases. ([3ab3733](https://github.com/ethers-io/ethers.js/commit/3ab373334c75800f2b20b6639ed8eb1b11e453ef))
- Fixed scrypt import in ESM build. ([b72ef27](https://github.com/ethers-io/ethers.js/commit/b72ef27b2a8f9941fb9d79122ec449fed9d2464d))
- Fixed null apiKey problem for InfuraProvider. ([e518151](https://github.com/ethers-io/ethers.js/commit/e51815150912d10e2734707986b10b37c87d6d12))
- Added support for sighash-style tuple parsing. ([19aaade](https://github.com/ethers-io/ethers.js/commit/19aaade9c62510012cfd50ae487ebd1705a28678))
- Fixed solc imports for cli. ([c35ddaf](https://github.com/ethers-io/ethers.js/commit/c35ddaf646efa25e738fee604585a0a7af45b206))
- Added nonce manager to experimental index. ([8316406](https://github.com/ethers-io/ethers.js/commit/8316406977ea26ca2044d16f7b3bb6ba21ef5b43))
- Removing NodesmithProvider from default provider as it is being discontinued. ([01ca350](https://github.com/ethers-io/ethers.js/commit/01ca35036ca11a47f60890e5cae62e46a00f3da8))
- Moved bare ABI named functions and events from Interface into Contracts to simplify other consumers of Interface. ([da8ca2e](https://github.com/ethers-io/ethers.js/commit/da8ca2e8bc982fc3ea0343bb3c593a485ca1fef0))
- Added support for complex API keys including support for INFURA project secrets. ([#464](https://github.com/ethers-io/ethers.js/issues/464), [#651](https://github.com/ethers-io/ethers.js/issues/651), [#652](https://github.com/ethers-io/ethers.js/issues/652); [1ec5804](https://github.com/ethers-io/ethers.js/commit/1ec5804bd460f6948d4813469fdc7bf739baa6a6))
- Migrated to scrypt-js v3. ([75895fa](https://github.com/ethers-io/ethers.js/commit/75895fa1491e7542c755a102f4e4c190685fd2b6))
- Moved getDefaultProvider to providers package. ([51e4ef2](https://github.com/ethers-io/ethers.js/commit/51e4ef2b45b83a8d82923600a2fac544d70b0807))
- Migrating providers to modern syntax and scoping. ([#634](https://github.com/ethers-io/ethers.js/issues/634); [e1509a6](https://github.com/ethers-io/ethers.js/commit/e1509a6326dd2cb8bf7ed64b82dd3947b768a314))
- Migrating to modern syntax and scoping. ([#634](https://github.com/ethers-io/ethers.js/issues/634); [394c36c](https://github.com/ethers-io/ethers.js/commit/394c36cad43f229a94c72d21f94d1c7982a887a1))
- Added provider property to Web3Provider. ([#641](https://github.com/ethers-io/ethers.js/issues/641); [1d4f90a](https://github.com/ethers-io/ethers.js/commit/1d4f90a958da6364117353850d62535c9702abd2))
- Updated GitHub issue cache. ([494381a](https://github.com/ethers-io/ethers.js/commit/494381a6284cc8ed90bd8002d42a6b6d94dc1200))
- Force deploy receipt to address to be null. ([#573](https://github.com/ethers-io/ethers.js/issues/573); [d9d438a](https://github.com/ethers-io/ethers.js/commit/d9d438a119bb11f8516fc9cf02c534ab3816fcb3))
- Updated experimental NonceManager. ([3d514c8](https://github.com/ethers-io/ethers.js/commit/3d514c8dbb94e1c4ce5754463e683dd9dbe7c0aa))
- Fixed typo in error message. ([28339a9](https://github.com/ethers-io/ethers.js/commit/28339a9c8585392086da159a46df4afb8958915c))
- Added GitHub issue caching. ([fea867a](https://github.com/ethers-io/ethers.js/commit/fea867a206f007a17718396e486883a5e718aa29))
ethers/v5.0.0-beta.159 (2019-10-17 01:08)
-----------------------------------------
- Removing TypeScript build files from npm to fix excessive package diffs.
- Fixed getBlock for blockhashes with a leading 0. ([#629](https://github.com/ethers-io/ethers.js/issues/629); [12cfc59](https://github.com/ethers-io/ethers.js/commit/12cfc599656d7e3a6d3d9aa4e468592865a711cc))
ethers/v5.0.0-beta.158 (2019-09-28 01:56)
-----------------------------------------
- Added less-common, but useful, coding functions to Interface. ([778eb3b](https://github.com/ethers-io/ethers.js/commit/778eb3b425b5ab5b23d28e75be92feccd0fc56bc))
- Add response handling and 304 support to fetchJson. ([3d25882](https://github.com/ethers-io/ethers.js/commit/3d25882d6bf689740506b9c569f6e0d30da6f6a5))
- Allow numeric values in a transaction to be odd-lengthed hexstrings. ([#614](https://github.com/ethers-io/ethers.js/issues/614); [a12030a](https://github.com/ethers-io/ethers.js/commit/a12030ad29aa13c02aa75d9e0860f4986a0043b4))
- Simpler crypt for admin tools. ([828c8cf](https://github.com/ethers-io/ethers.js/commit/828c8cfd419ac4f8d11d978c2e2ff83eba5ae909))
ethers/v5.0.0-beta.157 (2019-09-08 02:43)
-----------------------------------------

24
README.md
View File

@ -1,11 +1,17 @@
The Ethers Project
==================
**EXPERIMENTAL!!!**
**EXPERIMENTAL**
This is just a development version to experiment with lerna.
This branch is the next release of ethers.js, which should
be promoted to the official release shortly.
**Do NOT use**
I would recommend it for most new projects and personally use
it for my own projects.
The [new documentation](https://docs-beta.ethers.io) is still a
bit sparse, but is coming along as well and will be complete
before the promotion to master.
Installing
@ -17,10 +23,18 @@ Installing
/home/ricmoo/some_project> npm install --save ethers@next
```
**browser**
**browser (UMD)**
```
<script src="https://cdn.ethers.io/lib/ethers-5.0.min.js" type="text/javasctipt">
<script src="https://cdn.ethers.io/lib/ethers-5.0.umd.min.js" type="text/javasctipt">
</script>
```
**browser (ESM)**
```
<script type="module">
import { ethers } from "https://cdn.ethers.io/lib/ethers-5.0.umd.min.js";
</script>
```

16
admin/build.js
View File

@ -36,7 +36,7 @@ function run(progname, args, ignoreErrorStream) {
console.log("ERROR");
console.log(stderr.toString());
let error = new Error("stderr not empty");
let error = new Error(`stderr not empty: ${ progname } ${ JSON.stringify(args) }`);
error.stderr = stderr.toString();
error.stdout = stdout.toString();
error.statusCode = code;
@ -69,15 +69,17 @@ function setupConfig(outDir, moduleType, targetType) {
if (info._ethers_nobuild) { return; }
if (info.browser) {
if (typeof(info.browser) === "string") {
info.browser = update(info.browser);
[ "browser", "_browser" ].forEach((key) => {
if (info[key]) {
if (typeof(info[key]) === "string") {
info[key] = update(info[key]);
} else {
for (let key in info.browser) {
info.browser[key] = update(info.browser[key]);
for (let k in info[key]) {
info[key][k] = update(info[key][k]);
}
}
}
});
savePackage(dirname, info);
let path = resolve(__dirname, "../packages", dirname, "tsconfig.json");
@ -103,7 +105,7 @@ function runBuild(buildModule) {
}
function runDist() {
return run("npm", [ "run", "_dist_ethers" ], true);
return run("npm", [ "run", "_dist" ], true);
}
module.exports = {

10
admin/cmds/cache-github.js Normal file
View File

@ -0,0 +1,10 @@
"use strict";
const config = require("../config");
const { syncIssues } = require("../github");
(async function() {
const user = await config.get("github-user");
const password = await config.get("github-readonly");
await syncIssues(user, password);
})();

142
admin/cmds/grep-github.js Normal file
View File

@ -0,0 +1,142 @@
"use strict";
const { colorify } = require("../log");
const { getIssues } = require("../github");
const { repeat } = require("../utils");
const Options = {
"body": 1,
"end": 1,
"issue": 1,
"start": 1,
"title": 1,
"user": 1,
};
const Flags = {
"open": 1,
"match-case": 1,
};
(async function() {
const options = { };
for (let i = 2; i < process.argv.length; i++) {
const option = process.argv[i];
if (option.substring(0, 2) === "--") {
const comps = option.substring(2).split(/=/);
if (Flags[comps[0]]) {
if (comps[1] != null) { throw new Error("Invalid flag: " + option); }
options[comps[0]] = true;
} else if (Options[comps[0]]) {
if (comps[1] == null) {
options[comps[0]] = process.argv[++i];
if (options[comps[0]] == null) {
throw new Error("Missing option value: " + option);
}
} else {
options[comps[0]] = comps[1];
}
} else {
throw new Error("Unexpected option: " + option);
}
} else {
throw new Error("Unexpected argument: " + option);
}
}
if (options["title"]) { options.title = new RegExp(options.title, (options["match-case"] ? "": "i")); }
if (options["body"]) { options.body = new RegExp(options.title, (options["match-case"] ? "": "i")); }
if (options["start"]) {
if (options["start"].match(/^[0-9]{4}-[0-9]{2}-[0-9{2}]$/)) {
throw new Error("Expected YYYY-MM-DD");
}
}
if (options["end"]) {
if (options["end"].match(/^[0-9]{4}-[0-9]{2}-[0-9{2}]$/)) {
throw new Error("Expected YYYY-MM-DD");
}
}
const count = { issues: 0, comments: 0, code: 0, responses: 0 };
const issues = await getIssues();
issues.forEach((issue) => {
const info = issue.issue;
const comments = issue.comments;
if (options.issue && parseInt(options.issue) != info.number) { return; }
if (options.open && info.state !== "open") { return; }
if (options.title && !info.title.match(options.title)) { return; }
if (options.body) {
const body = info.body + "\n" + comments.map((c) => (c.body)).join("\n");
if (!body.match(options.body)) {
return;
}
}
if (options.user) {
const users = comments.map((c) => (c.user.login));
users.push(info.user.login);
if (users.indexOf(options.user) === -1) {
return;
}
}
const dates = comments.map((c) => (c.created_at.split("T")[0]));
dates.push(info.created_at.split("T")[0]);
if (options.start) {
if (dates.filter((d) => (d >= options.start)).length === 0) { return; }
}
if (options.end) {
if (dates.filter((d) => (d <= options.start)).length === 0) { return; }
}
count.issues++;
console.log(colorify(repeat("=", 70), "bold"))
console.log(colorify("Issue:", "bold"), info.title, ` (#${ info.number })`);
console.log(colorify("User:","bold"), colorify(info.user.login, "blue"));
console.log(colorify("State:", "bold"), info.state);
if (info.created_at === info.updated_at) {
console.log(colorify("Created:", "bold"), info.created_at);
} else {
console.log(colorify("Created:", "bold"), info.created_at, ` (updated: ${ info.updated_at })`);
}
info.body.trim().split("\n").forEach((line) => {
console.log(" " + line);
});
if (comments.length) {
comments.forEach((info) => {
if (options.start && info.created_at < options.start) { return ; }
if (options.end && info.created_at > options.end) { return; }
count.comments++;
if (options.user && info.user.login !== options.user) { return; }
count.responses++;
if (info.body.indexOf("`") >= 0) { count.code++; }
console.log(colorify(repeat("-", 70), "bold"));
console.log(colorify("User:", "bold"), colorify(info.user.login, "green"));
if (info.created_at === info.updated_at) {
console.log(colorify("Created:", "bold"), info.created_at);
} else {
console.log(colorify("Created:", "bold"), info.created_at, ` (updated: ${ info.updated_at })`);
}
info.body.trim().split("\n").forEach((line) => {
console.log(" " + line);
});
});
}
});
console.log(colorify(repeat("=", 70), "bold"))
// @TODO: Add stats on new/closed issues
//if (options.user) {
// console.log(`${ count.responses } responses (${ count.code } w/ code) on ${ count.comments } comments across ${ count.issues } issues.`);
//} else {
console.log(`${ count.comments } comment${ (count.comments !== 1) ? "s": "" } across ${ count.issues } issue${ (count.issues !== 1) ? "s": ""}.`);
//}
})().catch((error) => {
console.log("Error: " + error.message);
});

2
admin/cmds/publish.js
View File

@ -36,7 +36,7 @@ if (process.argv.length > 2) {
// Load the token from the encrypted store
try {
token = await config.get("token");
token = await config.get("npm-token");
} catch (error) {
switch (error.message) {
case "wrong password":

16
admin/cmds/set-config.js Normal file
View File

@ -0,0 +1,16 @@
"use strict";
const { prompt } = require("../../packages/cli");
const config = require("../config");
if (process.argv.length !== 3) {
console.log("Usage: set-config KEY");
process.exit(1);
}
const key = process.argv[2];
(async function() {
const value = await prompt.getPassword("Value: ");
await config.set(key, value);
})();

44
admin/cmds/set-option.js Executable file
View File

@ -0,0 +1,44 @@
const { setupBuild } = require("../build");
const { loadPackage, savePackage } = require("../local");
const arg = process.argv[2];
(async function() {
switch(arg) {
case "esm":
setupBuild(true);
break;
case "cjs":
setupBuild(false);
break;
case "browser-lang-en": {
const info = loadPackage("wordlists");
if (info._browser) {
info.browser = info._browser;
delete info._browser;
savePackage("wordlists", info);
}
break;
}
case "browser-lang-all": {
const info = loadPackage("wordlists");
if (info.browser) {
info._browser = info.browser;
delete info.browser;
savePackage("wordlists", info);
}
break;
}
default:
console.log("unknown option");
return 1;
}
return 0;
})().then((result) => {
process.exit(result);
});

10
admin/cmds/update-exports.js
View File

@ -8,8 +8,18 @@ const targets = sourceEthers.match(/export\s*{\s*((.|\s)*)}/)[1].trim();
const output = `"use strict";
// To modify this file, you must update ./admin/cmds/update-exports.js
import * as ethers from "./ethers";
try {
const anyGlobal = (window as any);
if (anyGlobal._ethers == null) {
anyGlobal._ethers = ethers;
}
} catch (error) { }
export { ethers };
export {

172
admin/cmds/upload-docs.js Normal file
View File

@ -0,0 +1,172 @@
"use strict";
const crypto = require('crypto');
const fs = require('fs');
const path = require('path');
const AWS = require('aws-sdk');
const config = require("../config");
const Bucket = "docs-beta.ethers.io";
function _getKeys(s3, result, nextToken, callback) {
const params = {
Bucket: Bucket,
MaxKeys: 1000,
ContinuationToken: nextToken,
};
s3.listObjectsV2(params, function(error, data) {
if (error) {
console.log(error);
callback(error);
return;
}
data.Contents.forEach(function(item) {
result[item.Key] = item.ETag.replace(/"/g,'');
});
callback(null, data.IsTruncated ? data.NextContinuationToken: null);
});
}
function getKeys(s3) {
const result = {};
return new Promise(function(resolve, reject) {
function handleBlock(error, nextToken) {
if (error) {
reject(error);
} else if (nextToken) {
nextBlock(nextToken);
} else {
resolve(result);
}
}
function nextBlock(nextToken) {
_getKeys(s3, result, nextToken, handleBlock);
}
nextBlock(undefined);
});
}
function getMime(filename) {
const comps = filename.split('.');
const ext = comps[comps.length - 1];
switch (ext.toLowerCase()) {
case 'css': return 'text/css';
case 'doctree': return 'application/x-doctree';
case 'eot': return 'application/vnd.ms-fontobject';
case 'gif': return 'image/gif';
case 'html': return 'text/html';
case 'js': return 'application/javascript';
case 'jpg': return 'image/jpeg';
case 'jpeg': return 'image/jpeg';
case 'md': return 'text/markdown';
case 'pickle': return 'application/x-pickle';
case 'png': return 'image/png';
case 'svg': return 'image/svg+xml';
case 'ttf': return 'application/x-font-ttf';
case 'txt': return 'text/plain';
case 'woff': return 'application/font-woff';
}
console.log('NO MIME', filename);
return undefined;
}
function putObject(s3, name, content) {
return new Promise(function(resolve, reject) {
s3.putObject({
ACL: 'public-read',
Body: content,
Bucket: Bucket,
ContentType: getMime(name),
Key: name
}, function(error, data) {
if (error) {
reject(error);
} else {
console.log('Uplodaed:', name)
resolve({
name: name,
hash: data.ETag.replace(/"/g, '')
});
}
});
});
}
function hash(filename) {
const hasher = crypto.createHash('md5');
hasher.update(fs.readFileSync(filename));
return hasher.digest().toString('hex');
}
function _getFiles(result, root) {
fs.readdirSync(root).forEach(function(filename) {
// We don't need to upload junk
if (filename === '.DS_Store') { return; }
const fullFilename = path.join(root, filename)
const stat = fs.statSync(fullFilename);
if (stat.isDirectory()) {
_getFiles(result, fullFilename);
} else {
result[fullFilename] = hash(fullFilename);
}
});
}
function getFiles(dirs) {
const result = { } //"index.html": hash("index.html") };
dirs.forEach(function(dir) {
_getFiles(result, dir);
})
return result;
}
(async function() {
const awsAccessId = await config.get("aws-upload-docs-accesskey");
const awsSecretKey = await config.get("aws-upload-docs-secretkey");
const s3 = new AWS.S3({
apiVersion: '2006-03-01',
accessKeyId: awsAccessId,
secretAccessKey: awsSecretKey
});
const added = [], removed = [], changed = [], upload = [];
const local = await getFiles([ "docs" ]);
const remote = await getKeys(s3);
Object.keys(local).forEach((filename) => {
if (!remote[filename]) {
added.push(filename);
upload.push(filename);
} else if (remote[filename] != local[filename]) {
changed.push(filename);
upload.push(filename);
}
});
Object.keys(remote).forEach((filename) => {
if (!local[filename]) {
removed.push(filename);
} else if (!local[filename] && remote[filename] != local[filename]) {
changed.push(filename);
upload.push(filename);
}
});
console.log('Added: ', added.length);
console.log('Removed: ', removed.length);
console.log('Changed: ', changed.length);
for (let i = 0; i < upload.length; i++) {
const filename = upload[i];
console.log("Uploading:", filename);
await putObject(s3, filename, fs.readFileSync(filename));
}
})();

121
admin/config.js
View File

@ -13,75 +13,96 @@ const computeHmac = require("../packages/sha2").computeHmac;
const colorify = require("./log").colorify;
function getConfigFilename() {
return resolve(os.homedir(), ".ethers-dist");
}
function getScrypt(message, password, salt) {
let progressBar = prompt.getProgressBar(message);
return new Promise((resolve, reject) => {
scrypt(Buffer.from(password), Buffer.from(salt), (1 << 17), 8, 1, 64, (error, progress, key) => {
if (error) { return reject(error); }
progressBar(progress);
if (key) { resolve(key); }
});
});
return scrypt.scrypt(Buffer.from(password), Buffer.from(salt), (1 << 17), 8, 1, 64, progressBar);
}
async function loadConfig(dkey) {
let config = { };
function Config(filename) {
this.salt = null;
this.dkey = null;
this.values = { };
this.filename = filename;
}
let filename = getConfigFilename();
if (fs.existsSync(filename)) {
let data = JSON.parse(fs.readFileSync(filename));
let ciphertext = Buffer.from(data.ciphertext, "base64");
let iv = Buffer.from(data.iv, "base64");
let aes = new AES.ModeOfOperation.ctr(dkey.slice(0, 32), new AES.Counter(iv));
let plaintext = aes.decrypt(ciphertext);
let hmac = computeHmac("sha512", dkey.slice(32, 64), plaintext);
Config.prototype.load = async function() {
if (this.dkey) { return; }
let data = null;
if (fs.existsSync(this.filename)) {
data = JSON.parse(fs.readFileSync(this.filename));
} else {
data = {
salt: Buffer.from(randomBytes(32)).toString("hex")
};
}
this.salt = data.salt;
const password = await prompt.getPassword(colorify("Password (config-store): ", "bold"));
this.dkey = await getScrypt(colorify("Unlocking config", "bold"), password, this.salt);
if (data.ciphertext) {
const ciphertext = Buffer.from(data.ciphertext, "base64");
const iv = Buffer.from(data.iv, "base64");
const aes = new AES.ModeOfOperation.ctr(this.dkey.slice(0, 32), new AES.Counter(iv));
const plaintext = aes.decrypt(ciphertext);
const hmac = computeHmac("sha512", this.dkey.slice(32, 64), plaintext);
if (hmac !== data.hmac) {
throw new Error("wrong password");
}
config = JSON.parse(Buffer.from(plaintext).toString());
this.values = JSON.parse(Buffer.from(plaintext).toString());
}
};
return config;
}
Config.prototype.save = function() {
this.values._junk = Buffer.from(randomBytes(16 + parseInt(Math.random() * 48))).toString("base64")
async function getConfig(key) {
let password = await prompt.getPassword(colorify("Password (seesion-store): ", "bold"));
let dkey = await getScrypt(colorify("Decrypting", "bold"), password, key);
const plaintext = Buffer.from(JSON.stringify(this.values));
let config = await loadConfig(dkey);
return config[key];
}
const iv = Buffer.from(randomBytes(16));
const hmac = computeHmac("sha512", this.dkey.slice(32, 64), plaintext);
async function setConfig(key, value) {
let password = await prompt.getPassword(colorify("Password (seesion-store): ", "bold"));
let dkey = await getScrypt("Encrypting", password, key);
const aes = new AES.ModeOfOperation.ctr(this.dkey.slice(0, 32), new AES.Counter(iv));
const ciphertext = Buffer.from(aes.encrypt(plaintext));
let config = await loadConfig(dkey);
config[key] = value;
config._junk = Buffer.from(randomBytes(16 + parseInt(Math.random() * 48))).toString("base64")
let plaintext = Buffer.from(JSON.stringify(config));
let iv = Buffer.from(randomBytes(16));
let hmac = computeHmac("sha512", dkey.slice(32, 64), plaintext);
let aes = new AES.ModeOfOperation.ctr(dkey.slice(0, 32), new AES.Counter(iv));
let ciphertext = Buffer.from(aes.encrypt(plaintext));
let data = {
const data = {
ciphertext: ciphertext.toString("base64"),
iv: iv.toString("base64"),
salt: this.salt,
hmac: hmac
};
fs.writeFileSync(getConfigFilename(), JSON.stringify(data, null, 2));
fs.writeFileSync(this.filename, JSON.stringify(data, null, 2));
}
module.exports = {
get: getConfig,
set: setConfig
Config.prototype.get = async function(key) {
await this.load();
return this.values[key];
};
Config.prototype.set = async function(key, value) {
await this.load();
this.values[key] = value;
this.save();
};
Config.prototype.lock = function() {
this.salt = this.dkey = null;
}
const config = new Config(resolve(os.homedir(), ".ethers-dist"));
module.exports = {
get: function(key) {
return config.get(key);
},
set: function(key, value) {
config.set(key, value);
},
lock: function() {
config.lock();
}
}

134
admin/github.js Normal file
View File

@ -0,0 +1,134 @@
"use strict";
const fs = require("fs");
const { resolve } = require("path");
const zlib = require("zlib");
const { id } = require("../packages/hash");
const { fetchJson } = require("../packages/web");
const CacheDir = resolve(__dirname, "../github-cache/");
function addResponse(result, response) {
return { result, response };
}
function loadFile(filename) {
return JSON.parse(zlib.gunzipSync(fs.readFileSync(filename)).toString());
//return JSON.parse(fs.readFileSync(filename).toString());
}
// @TODO: atomic
function saveFile(filename, content) {
fs.writeFileSync(filename, zlib.gzipSync(JSON.stringify(content)));
//fs.writeFileSync(filename, JSON.stringify(content));
}
function mockFetchJson(url, body, headers) {
return {
result: null,
response: {
statusCode: 304
}
}
}
async function _fetchGitHub(user, password, fetchJson, url) {
const result = [ ];
while (true) {
const filename = resolve(CacheDir, id(url).substring(2, 14));
const headers = {
"User-Agent": "ethers-io",
};
let items = null;
let link = null;
try {
const data = loadFile(filename);
headers["if-none-match"] = data.etag;
items = data.items;
link = data.link;
} catch (error) {
if (error.code !== "ENOENT") { throw error; }
}
const fetch = await fetchJson({
url: url,
user: user,
password: password,
headers: headers
}, null, addResponse);
// Cached response is good; use it!
if (fetch.response.statusCode !== 304) {
items = fetch.result;
if (fetch.response.headers) {
link = (fetch.response.headers.link || null);
}
if (fetch.response.headers.etag){
saveFile(filename, {
timestamp: (new Date()).getTime(),
url: url,
link: link,
etag: fetch.response.headers.etag,
items: items,
version: 1
});
}
}
items.forEach((item) => { result.push(item)});
url = null;
(link || "").split(",").forEach((item) => {
if (item.indexOf('rel="next"') >= 0) {
const match = item.match(/<([^>]*)>/);
if (match) { url = match[1]; }
}
});
if (!url) { break; }
}
return result;
}
async function fetchGitHub(user, password, url, cacheOnly) {
if (cacheOnly) {
return await _fetchGitHub("none", "none", mockFetchJson, url);
}
const results = await _fetchGitHub(user, password, fetchJson, url);
return results;
}
async function _getIssues(user, password) {
const cacheOnly = (user == null);
let issues = await fetchGitHub(user, password, "https://api.github.com/repos/ethers-io/ethers.js/issues?state=all&per_page=100", cacheOnly)
if (!cacheOnly) { console.log(`Found ${ issues.length } issues`); }
const result = [ ];
for (let i = 0; i < issues.length; i++) {
const issue = issues[i];
let comments = await fetchGitHub(user, password, issue.comments_url, cacheOnly);
result.push({ issue, comments});
if (!cacheOnly) { console.log(` Issue ${ issue.number }: ${ comments.length } comments`); }
}
result.sort((a, b) => (a.issue.number - b.issue.number));
return result;
}
function getIssues() {
return _getIssues();
}
function syncIssues(user, password) {
return _getIssues(user, password);
}
module.exports = {
getIssues,
syncIssues,
}

14
admin/local.js
View File

@ -15,8 +15,20 @@ const keccak256 = (function() {
const { dirnames, loadPackage, ROOT } = require("./depgraph");
const { resolve, saveJson } = require("./utils");
function sorted(obj) {
if (Array.isArray(obj)) { return obj.map(sorted); }
if (obj == null || typeof(obj) !== "object") { return obj; }
const keys = Object.keys(obj);
keys.sort();
const result = { };
keys.forEach((key) => { result[key] = sorted(obj[key]); });
return result;
}
function savePackage(dirname, info) {
return saveJson(resolve(ROOT, dirname, "package.json"), info);
return saveJson(resolve(ROOT, dirname, "package.json"), sorted(info));
}
async function createTarball(dirname) {

50
admin/test-parity/parity-dev.json Normal file
View File

@ -0,0 +1,50 @@
{
"name": "DevelopmentChain",
"engine": {
"instantSeal": null
},
"params": {
"gasLimitBoundDivisor": "0x0400",
"accountStartNonce": "0x0",
"maximumExtraDataSize": "0x20",
"minGasLimit": "0x1388",
"networkID" : "0x11",
"registrar" : "0x0000000000000000000000000000000000001337",
"maxCodeSize": 24576,
"maxCodeSizeTransition": "0x0",
"eip98Transition": "0x7fffffffffffff",
"eip140Transition": "0x0",
"eip145Transition": "0x0",
"eip150Transition": "0x0",
"eip155Transition": "0x0",
"eip160Transition": "0x0",
"eip161abcTransition": "0x0",
"eip161dTransition": "0x0",
"eip211Transition": "0x0",
"eip214Transition": "0x0",
"eip658Transition": "0x0",
"wasmActivationTransition": "0x0"
},
"genesis": {
"seal": {
"generic": "0x0"
},
"difficulty": "0x20000",
"author": "0x0000000000000000000000000000000000000000",
"timestamp": "0x00",
"parentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
"extraData": "0x",
"gasLimit": "0x7A1200"
},
"accounts": {
"0000000000000000000000000000000000000001": { "balance": "1", "builtin": { "name": "ecrecover", "pricing": { "linear": { "base": 3000, "word": 0 } } } },
"0000000000000000000000000000000000000002": { "balance": "1", "builtin": { "name": "sha256", "pricing": { "linear": { "base": 60, "word": 12 } } } },
"0000000000000000000000000000000000000003": { "balance": "1", "builtin": { "name": "ripemd160", "pricing": { "linear": { "base": 600, "word": 120 } } } },
"0000000000000000000000000000000000000004": { "balance": "1", "builtin": { "name": "identity", "pricing": { "linear": { "base": 15, "word": 3 } } } },
"0000000000000000000000000000000000000005": { "balance": "1", "builtin": { "name": "modexp", "activate_at": 0, "pricing": { "modexp": { "divisor": 20 } } } },
"0000000000000000000000000000000000000006": { "balance": "1", "builtin": { "name": "alt_bn128_add", "activate_at": 0, "pricing": { "linear": { "base": 500, "word": 0 } } } },
"0000000000000000000000000000000000000007": { "balance": "1", "builtin": { "name": "alt_bn128_mul", "activate_at": 0, "pricing": { "linear": { "base": 40000, "word": 0 } } } },
"0000000000000000000000000000000000000008": { "balance": "1", "builtin": { "name": "alt_bn128_pairing", "activate_at": 0, "pricing": { "alt_bn128_pairing": { "base": 100000, "pair": 80000 } } } },
"0x7454a8f5a7c7555d79b172c89d20e1f4e4cc226c": { "balance": "1606938044258990275541962092341162602522202993782792835301376" }
}
}

1
admin/test-parity/parity-dev.pwds Normal file
View File

@ -0,0 +1 @@

1
admin/test-parity/parity-keys/UTC--2019-06-25T00-14-25Z--24d70b97-fff9-d322-e760-4b8cc2e21751 Normal file
View File

@ -0,0 +1 @@
{"id":"24d70b97-fff9-d322-e760-4b8cc2e21751","version":3,"crypto":{"cipher":"aes-128-ctr","cipherparams":{"iv":"45d392cd16dbbd5c0f5b2d145c112da9"},"ciphertext":"b001ccd09fc5431dc055975b58ee61f86e85529245506c04182c902716e750e5","kdf":"pbkdf2","kdfparams":{"c":10240,"dklen":32,"prf":"hmac-sha256","salt":"028594da27a0e864105f33b912e5dc6ce7c75ecd13c81bfc158fe963d30c93bb"},"mac":"374bf2e9144b74b889708abc19e9ebc164f90bc27e83fd9f01da4571a9f81a70"},"address":"7454a8f5a7c7555d79b172c89d20e1f4e4cc226c","name":"","meta":"{}"}

2
admin/utils.js
View File

@ -25,7 +25,7 @@ function getDate(date) {
function getDateTime(date) {
return getDate(date) + " " + [
date.getHours(),
zpad(date.getHours()) ,
zpad(date.getMinutes() + 1)
].join(":");
}

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

@ -13,7 +13,7 @@ To mitigate these issues, it is recommended you use a
[Default Provider](get-default-provider).
_subsection: EtherscanProvider
_subsection: EtherscanProvider @INHERIT<[[provider]]>
The **EtherscanProvider** is backed by a combination of the various
[Etherscan APIs](https://etherscan.io/apis).
@ -21,7 +21,7 @@ The **EtherscanProvider** is backed by a combination of the various
_property: provider.getHistory(address) => Array<History>
_subsection: InfuraProvider
_subsection: InfuraProvider @INHERIT<[[urljsonrpc-provider]]>
The **InfuraProvider** is backed by the popular [INFURA](https://infura.io)
Ethereum service.
@ -30,7 +30,7 @@ It supports Mainnet (homestead) and all common testnets (Ropsten, Rinkeby,
G&ouml;rli and Kovan).
_subsection: NodesmithProvider
_subsection: NodesmithProvider @INHERIT<[[urljsonrpc-provider]]>
The **NodesmithProvider** is backed by [Nodesmith](https://nodesmith.io).
@ -38,7 +38,7 @@ It supports Mainnet (homestead) and all common testnets (Ropsten, Rinkeby,
G&ouml;rli and Kovan), as well as the Ethereum-like network [Aion](https://aion.network).
_subsection: AlchemyProvider
_subsection: AlchemyProvider @INHERIT<[[urljsonrpc-provider]]>
The **AlchemtProvider** is backed by [Alchemy](https://alchemyapi.io).
@ -46,7 +46,7 @@ It supports Mainnet (homestead) and all common testnets (Ropsten, Rinkeby,
G&ouml;rli and Kovan).
_subsection: CloudfrontProvider
_subsection: CloudfrontProvider @INHERIT<[[urljsonrpc-provider]]>
The CloudfrontProvider is backed by the
[Cloudflare Ethereum Gateway](https://developers.cloudflare.com/distributed-web/ethereum-gateway/).

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

@ -4,19 +4,24 @@ _section: JSON-RPC Provider
Explain here...
_subsection: JsonRpcProvider @<jsonrpc-provider>
_subsection: JsonRpcProvider @<jsonrpc-provider> @INHERIT<[[provider]]>
TODO...
_property: provider.getSigner([ addressOrIndex ]) => [[jsonrpc-signer]]
_property: jsonRpcProvider.getSigner([ addressOrIndex ]) => [[jsonrpc-signer]] @<provider-getsigner> @SRC<providers/json-rpc-provider>
Returns a [[jsonrpc-signer]] which is managed by this Ethereum node, at
//addressOrIndex//. If no //addressOrIndex// is provided, the first
account (account #0) is used.
_property: provider.getUncheckSigner([ addressOrIndex ]) => [[jsonrpc-uncheckedsigner]]
_property: jsonRpcProvider.getUncheckedSigner([ addressOrIndex ]) => [[jsonrpc-uncheckedsigner]] @<provider-getuncheckedsigner> @SRC<providers/json-rpc-provider>
_subsection: JsonRpcSigner @<jsonrpc-signer>
_property: jsonRpcProvider.listAccounts() => Array<string> @<provider-listaccounts> @SRC<providers/json-rpc-provider>
_property: jsonRpcProvider.send(method, params) => Promise<any> @<provider-send> @SRC<providers/json-rpc-provider>
_subsection: JsonRpcSigner @<jsonrpc-signer> @INHERIT<[[signer]]>
TODO... Explain
_subsection: JsonRpcUncheckedSigner @<jsonrpc-uncheckedsigner>
_subsection: JsonRpcUncheckedSigner @<jsonrpc-uncheckedsigner> @INHERIT<[[signer]]>
TODO... Explain

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

@ -4,7 +4,7 @@ _section: Other Providers
Others...
_subsection: FallbackProvider @<provider-fallback>
_subsection: FallbackProvider @<provider-fallback> @INHERIT<[[provider]]>
Explain...
@ -21,7 +21,17 @@ _property: provider.weights => Array<number>
The weight each of the Providers adds to a results acceptance.
_subsection: IpcProvider @<provider-ipc>
_subsection: IpcProvider @<provider-ipc> @INHERIT<[[jsonrpc-provider]]>
Explain...
_subsection: UrlJsonRpcProvider @<urljsonrpc-provider> @INHERIT<[[jsonrpc-provider]]>
Tra la la
_subsection: Web3Provider @<web3provider> @INHERIT<[[jsonrpc-provider]]>
Tra la la

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

@ -8,17 +8,17 @@ Explain what a provider is...
_subsection: Accounts Methods
_property: provider.getBalance(address [ , blockTag = "latest" ]) => Promise<[[bignumber]]>
_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<[[hexstring]]>
_property: provider.getCode(address [ , blockTag = "latest" ]) => Promise<string<[[datahexstring]]>> @<providers-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(address, position [ , blockTag = "latest" ]) => Promise<[[hexstring]]>
Returns the ``Bytes32`` value of the //position// at //address//, as of the //blockTag//.
_property: provider.getStorageAt(addr, pos [ , blockTag = "latest" ]) => Promise<string<[[datahexstring]]>> @<providers-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>
_property: provider.getTransactionCount(address [ , blockTag = "latest" ]) => Promise<number> @<providers-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.
@ -30,11 +30,11 @@ _code: example-account.js
_subsection: Blocks Methods
_property: provider.getBlock(block) => Promise<[[provider-block]]>
_property: provider.getBlock(block) => Promise<[[provider-block]]> @<providers-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]]>
_property: provider.getBlockWithTransactions(block) => Promise<[[provider-blocktxs]]> @<providers-getblockwithtransactions> @SRC<providers/base-provider>
Get the //block// from the network, where the ``result.transactions`` is
an Array of [[provider-transactionresponse]] objects.
@ -43,12 +43,12 @@ _subsection: Ethereum Naming Service (ENS) Methods
TODO: Explain ENS here...
_property: provider.lookupAddress(address) => Promise<string>
_property: provider.lookupAddress(address) => Promise<string> @<providers-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.resovleName(name) => Promise<string>
_property: provider.resolveName(name) => Promise<string<[Address](address)>> @<providers-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.
@ -59,7 +59,7 @@ _code: example-ens.js
_subsection: Logs Methods
_property: provider.getLogs(filter) => Promise<Array<[[provider-log]]>>
_property: provider.getLogs(filter) => Promise<Array<[[provider-log]]>> @<providers-getlogs> @SRC<providers/base-provider>
Returns the Array of [[provider-log]] matching the //filter//.
Keep in mind that many backends will discard old events, and that requests
@ -69,24 +69,24 @@ execute the query.
_subsection: Network Status Methods
_property: provider.getNetwork() => Promise<[[provider-network]]>
_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.getBlockNumber() => Promise<number>
_property: provider.getBlockNumber() => Promise<number> @<providers-getblocknumber> @SRC<providers/base-provider>
Returns the block number (or height) of the most recently mined block.
_property: provider.getGasPrice() => Promise<[[bignumber]]>
_property: provider.getGasPrice() => Promise<[[bignumber]]> @<providers-getgasprice> @SRC<providers/base-provider>
Returns a //best guess// of the [[gas-price]] to use in a transaction.
_subsection: Transactions Methods
_property: provider.call(transaction [ , blockTag = "latest" ]) => Promise<[[hexstring]]>
_property: provider.call(transaction [ , blockTag = "latest" ]) => Promise<string<[[hexstring]]>> @<providers-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]]>
_property: provider.estimateGas(transaction) => Promise<[[bignumber]]> @<providers-estimategas> @SRC<providers/base-provider>
Returns an estimate of the amount of gas that would be required to submit //transaction//
to the network.
@ -94,12 +94,12 @@ 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]]>
_property: provider.sendTransaction(transaction) => Promise<[[provider-transactionresponse]]> @<providers-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(transactionHash) => Promise<[[provider-transactionreceipt]]>
_property: provider.waitForTransaction(transactionHash) => Promise<[[provider-transactionreceipt]]> @<providers-waitfortransaction> @SRC<providers/base-provider>
Returns a Promise which will not resolve until //transactionHash// is mined.
@ -107,35 +107,35 @@ _subsection: Event Emitter Methods
Explain events here...
_property: provider.on(eventName, listener) => this
_property: provider.on(eventName, listener) => this @<providers-on> @SRC<providers/base-provider>
Add a //listener// to be triggered for each //eventName//.
_property: provider.once(eventName, listener) => this
_property: provider.once(eventName, listener) => this @<providers-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
_property: provider.emit(eventName, ...args) => boolean @<providers-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
_property: provider.off(eventName [ , listener ]) => this @<providers-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
_property: provider.removeAllListeners([ eventName ]) => this @<providers-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
_property: provider.listenerCount([ eventName ]) => number @<providers-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>
_property: provider.listeners(eventName) => Array<Listener> @<providers-listeners> @SRC<providers/base-provider>
Returns the list of Listeners for //eventName//.
_subsection: Inspection Methods
_property: Provider.isProvider(object) => boolean
_property: Provider.isProvider(object) => boolean @<providers-isprovider> @SRC<abstract-provider>
Returns true if and only if //object// is a Provider.

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

@ -2,32 +2,195 @@ _title: Signer
_section: Signers
Tra la la...
A Signer represents...
_subsection: Signer @<signer>
_subsection: Signer @<signer> @SRC<abstract-signer:class.Signer>
_property: signer.connect(provider) => [[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 [[jsonrpc-signer]].
_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>
Returns a Promise that resolves to the account address.
This is a Promise so that a **Signer** can be designed around an
asynchronous source, such as hardware wallets.
Sub-classes **must** implement this.
_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>
_property: signer.getBalance([ blockTag = "latest" ]) => Promise<[[bignumber]]> @<signer-getbalance> @SRC<abstract-signer>
TODO
_heading: Blockchain Methods
_property: signer.getBalance([ blockTag = "latest" ]) => Promise<[[bignumber]]>
_property: signer.getChainId() => Promise<number> @<signer-getchainid> @SRC<abstract-signer>
TODO
_property: signer.getTransactionCount([ blockTag = "latest" ]) => Promise<number>
_property: signer.getGasPrice() => Promise<[[bignumber]]> @<signer-getgasprice> @SRC<abstract-signer>
TODO
_property: signer.getTransactionCount([ blockTag = "latest" ]) => Promise<number> @<signer-gettransactioncount> @SRC<abstract-signer>
TODO
_property: signer.call(transactionRequest) => Promise<string<[[datahexstring]]>> @<signer-call> @SRC<abstract-signer>
TODO
_property: signer.estimateGas(transactionRequest) => Promise<[[bignumber]]> @<signer-estimategas> @SRC<abstract-signer>
TODO
_property: signer.resolveName(name) => Promise<string<[Address](address)>> @<signer-resolvename> @SRC<abstract-signer>
TODO
_subsection: Wallet inherits Signer
_heading: Signing
_property: signer.signMessage(message) => Promise<string<[FlatSignature](signature-flat)>> @<signer-signmessage>
This returns a Promise which resolves to the [[signature-flat]]
of //message//.
Sub-classes **must** implement this, however they may throw if signing a
message is not supported.
_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
binary data.
For example, the string ``"0x1234"`` is 6 characters long (and in
this case 6 bytes long). This is **not** equivalent to the array
``[ 0x12, 0x34 ]``, which is 2 bytes long.
A common case is to sign a hash. In this case, if the hash is a
string, it **must** be converted to an array first, using the
[arrayify](utils-arrayify) utility function.
_null:
_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>
This method populates the transactionRequest with missing fields, using
[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>
It is very important that all important properties of a **Signer** are
**immutable**. Since Ethereum is very asynchronous and deals with critical
data (such as ether and other potentially valuable crypto assets), keeping
properties such as the //provider// and //address// static helps prevent
serious issues.
A sub-class **must** call ``super()``.
_property: signer.checkTransaction(transactionRequest) => [[provider-transactionrequest]] @<signer-checktransaction> @SRC<abstract-signer>
TODO
_property: signer.populateTransaction(transactionRequest) => Promise<[[provider-transactionrequest]]> @<signer-populatetransaction> @SRC<abstract-signer>
TODO
_subsection: Wallet @<wallet> @INHERIT<[[externally-owned-account]] and [[signer]]> @SRC<wallet:class.Wallet>
The Wallet class inherits [[signer]] and can sign transactions and messages
using a private key as a standard Externally Owned Account (EOA).
_heading: Creating an Instance
_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: new ethers.Wallet(privateKey [ , provider ])
TODO
_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: Wallet.fromEncryptedJson(json, password)
TODO
_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.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).
If wordlist is not specified, the English Wordlist is used.
_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]]
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
to the desired provider.
_property: wallet.publicKey => string<[[datahexstring]]<65>>
The uncompressed public key for this Wallet represents.
_heading: Methods
_property: wallet.encrypt(password, [ options = { }, [ progress ] ]) => Promise<string>
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>
A **VoidSigner** is a simple Signer which cannot sign.
It is useful as a read-only signer, when an API requires a
Signer as a parameter, but it is known only read-only operations
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]]
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>
_property: eoa.address => string<[Address](address)>
The [[address]] of this EOA.
_property: eoa.privateKey => string<[[datahexstring]]<32>>
The privateKey of this EOA
_property: eoa.mnemonic => string
//Optional//. The account HD mnemonic, if it has one and can be determined.
_property: eoa.path => string
//Optional//. The account HD path, if it has one and can be determined.

242
docs.wrm/api/utils/abi.wrm Normal file
View File

@ -0,0 +1,242 @@
_title: Application Binary Interface
_section: Application Binary Interface
Explain an ABI.
_subsection: Formats
_heading: JSON String ABI (Solidity Output JSON)
The **JSON ABI Format** is the format that is
[output from the Solidity compiler](https://solidity.readthedocs.io/en/v0.6.0/using-the-compiler.html#output-description).
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.
The deserialied JSON string (which is a normal JavaScript Object) may
also be passed into any function which accepts a JSON String ABI.
_heading: Humanb-Readable ABI
The Human-Readable ABI was
[article](https://blog.ricmoo.com/human-readable-contract-abis-in-ethers-js-141902f4d917)
_heading: Output Formats @<abi-outputformats> @src<abi/fragments:FormatTypes>
Each [[abi-fragment]] and [[abi-paramtype]] may be output using its ``format``
method.
_property: utils.FragmentTypes.full => string
This is a full human-readable string, including all parameter names, any
optional modifiers (e.g. ``indexed``, ``public``, etc) and white-space
to aid in human readabiliy.
_property: 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).
_property: utils.FragmentTypes.json => string
This returns a JavaScript Object which is safe to call ``JSON.stringify``
on to create a JSON string.
_property: utils.FragmentTypes.sighash => string
This is a minimal output format, which is used by Solidity when computing a
signature hash or an event topic hash.
_warning: Note
The ``sighash`` format is **insufficient** to re-create the original [[abi-fragment]],
since it discards modifiers such as indexed, anonymous, stateMutability, etc.
_subsection: Fragment @<abi-fragment> @SRC<abi/fragments:class.Fragment>
An ABI is a collection of **Fragments**, where each fragment specifies:
- An Event
- A Function
- A Constructor
_heading: Properties
_property: fragment.name => string
This is the name of the Event or Function. This will be null for
a [[abi-constructorfragment]].
_property: fragment.type => string
This is a string which indicates the type of the [[abi-fragment]]. This
will be one of:
- ``constructor``
- ``event``
- ``function``
_property: fragment.inputs => Array<[[abi-paramtype]]>
This is an array of of each [[abi-paramtype]] for the input parameters to
the Constructor, Event of Function.
_heading: Methods
_property: utils.Fragment.from(objectOrString) => [[abi-fragment]] @<abi-fragment-from> @SRC<abi/fragments:Fragment.from>
Returns a
_property: utils.Fragment.isFragment(object) => boolean @<abi-isfragment> @SRC<abi/fragments:Fragment.isFragment>
Tra lal al
_subsection: ConstructorFragment @<abi-constructorfragment> @INHERIT<[[abi-fragment]]> @SRC<abi/fragments:class.ConstructorFragment>
_heading: Properties
_property: fragment.gas => [[bignumber]]
This is the gas limit that should be used during deployment. It may be
null.
_property: fragment.payable => boolean
This is whether the constructor may receive ether during deployment as
an endowment (i.e. msg.value != 0).
_property: fragment.stateMutability => string
This is the state mutability of the constructor. It can be any of:
- ``nonpayable``
- ``payable``
_heading: Methods
_property: utils.ConstructorFragment.from(objectOrString) => [[abi-constructorfragment]] @<abi-constructorfragment-from> @SRC<abi/fragments:ConstructorFragment.from>
Tra la la...
_property: utils.ConstructorFragment.isConstructorFragment(object) => boolean @<abi-isconstructorfragment> @SRC<abi/fragments:ConstructorFragment.isConstructorFragment>
Tra lal al
_subsection: EventFragment @<abi-eventfragment> @INHERIT<[[abi-fragment]]> @SRC<abi/fragments:class.EventFragment>
_heading: Properties
_property: fragment.anonymous => boolean
This is whether the event is anonymous. An anonymous Event does not inject its
topic hash as topic0 when creating a log.
_heading: Methods
_property: utils.EventFragment.from(objectOrString) => [[abi-eventfragment]] @<abi-eventfragment-from> @SRC<abi/fragments:EventFragment.from>
Tra la la...
_property: utils.EventFragment.isEventFragment(object) => boolean @<abi-iseventfragment> @SRC<abi/fragments:EventFragment.isEventFragment>
Tra lal al
_subsection: FunctionFragment @<abi-functionfragment> @INHERIT<[[abi-constructorfragment]]> @SRC<abi/fragments:class.FunctionFragment>
_heading: Properties
_property: fragment.constant => boolean
This is whether the function is constant (i.e. does not change state). This
is true if the state mutability is ``pure`` or ``view``.
_property: fragment.stateMutability => string
This is the state mutability of the constructor. It can be any of:
- ``nonpayable``
- ``payable``
- ``pure``
- ``view``
_property: fragment.outputs => Array<[[abi-paramtype]]>
A list of the Function output parameters.
_heading: Method
_property: utils.FunctionFragment.from(objectOrString) => [[abi-functionfragment]] @<abi-functionfragment-from> @SRC<abi/fragments:ConstructorFragment.from>
Tra la la...
_property: utils.FunctionFragment.isFunctionFragment(object) => boolean @<abi-isfunctionfragment> @SRC<abi/fragments:FunctionFragment.isFunctionFragment>
Tra lal al
_subsection: ParamType @<abi-paramtype> @SRC<abi/fragments:class.ParamType>
The following examples will represent the Solidity parameter:
``string foobar``
_heading: Properties
_property: paramType.name => string @<abi-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>
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>
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
a tuple, it will be the string ``tuple``.
_property: paramType.indexed => boolean @<abi-paramtype-indexed>
Whether the parameter has been marked as indexed. This **only** applies
to parameters which are part of an [[abi-eventfragment]].
_property: paramType.arrayChildren => [[abi-paramtype]] @<abi-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>
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>
The components of a tuple. This is null for non-tuple parameters.
_heading: Methods
Tra la la...
_property: paramType.format([ outputType = "sighash" ])
Tra la la...
_property: utils.ParamType.from(objectOrString) => [[abi-paramtype]] @<abi-paramtype-from> @SRC<abi/fragments:ParamType.from>
Tra la la...
_property: utils.ParamType.isParamType(object) => boolean @<abi-paramtype-isparamtype> @SRC<abi/fragments:ParamType.isParamType>
Tra la la...

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

@ -1,21 +1,41 @@
_title: Addresses
_section: Addresses
_section: Addresses @<addresses>
Explain addresses,formats and checksumming here.
Also see: [Constants.AddressZero](constants)
Also see: [constants.AddressZero](constants)
_heading: Functions
_subsection: Address Formats @<address-formats>
_property: utils.getAddress(address) => string
_heading: Checksum Address @<address>
TODO
_property: utils.isAddress(address) => boolean
_heading: ICAP Address @<address-icap>
TODO
_property: utils.getIcapAddress(address) => string
TODO
_subsection: Functions
_property: utils.getContractAddress(transaction) => string
TODO
_property: utils.getAddress(address) => string<[Address](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
the checksum is invalid, an InvalidArgument Error is throw.
The value of //address// may be any supported address format.
_property: utils.isAddress(address) => boolean @<utils-isAddress> @SRC<address>
Returns true if //address// is valid (in any supported format).
_property: utils.getIcapAddress(address) => string<[IcapAddress](address-icap)> @<utils-getIcapAddress> @SRC<address>
Returns //address// as an [ICAP address](https://github.com/ethereum/wiki/wiki/Inter-exchange-Client-Address-Protocol-%28ICAP%29).
Supports the same restrictions as [utils.getAddress](utils-getAddress).
_property: utils.getContractAddress(transaction) => string<[Address](address)> @<utils-getContractAddress> @SRC<address>
Returns the contract address that would result if //transaction// was
used to deploy a contract.
_property: utils.getCreate2Address(from, salt, initCodeHash) => string<[Address](address)> @<utils.getCreate2Address> @SRC<address>
Returns the contract address that would result from the given
[CREATE2](https://eips.ethereum.org/EIPS/eip-1014) call.

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

@ -55,28 +55,28 @@ it represents.
_heading: Math Operations
_property: bignumber.add(otherValue) => [[bignumber]]
_property: bignumber.add(otherValue) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// **+** //otherValue//.
_property: bignumber.sub(otherValue) => [[bignumber]]
_property: bignumber.sub(otherValue) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// **&ndash;** //otherValue//.
_property: bignumber.mul(otherValue) => [[bignumber]]
_property: bignumber.mul(otherValue) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// **&times;** //otherValue//.
_property: bignumber.div(divisor) => [[bignumber]]
_property: bignumber.div(divisor) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// **&#247;** //divisor//.
_property: bignumber.mod(divisor) => [[bignumber]]
_property: bignumber.mod(divisor) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of the **remainder** of //bignumber// &#247; //divisor//.
_property: bignumber.pow(exponent) => [[bignumber]]
_property: bignumber.pow(exponent) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// to the power of //exponent//.
_property: bignumber.abs() => [[bignumber]]
_property: bignumber.abs() => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the absolute value of //bignumber//.
_property: bignumber.maskn(bitcount) => [[bignumber]]
_property: bignumber.maskn(bitcount) => [[bignumber]] @SRC<bignumber>
Returns a BigNumber with the value of //bignumber// with bits beyond
the //bitcount// least significant bits set to zero.
@ -88,53 +88,53 @@ 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]]
_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]]
_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
_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
_property: bignumber.lt(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //bignumber// **<** //otherValue//.
_property: bignumber.lte(otherValue) => boolean
_property: bignumber.lte(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //bignumber// **&le;** //otherValue//.
_property: bignumber.gt(otherValue) => boolean
_property: bignumber.gt(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //bignumber// **>** //otherValue//.
_property: bignumber.gte(otherValue) => boolean
_property: bignumber.gte(otherValue) => boolean @SRC<bignumber>
Returns true if and only if the value of //bignumber// **&ge;** //otherValue//.
_property: bignumber.isZero() => boolean
_property: bignumber.isZero() => boolean @SRC<bignumber>
Returns true if and only if the value of //bignumber// is zero.
_heading: Conversion
_property: bignumber.toNumber() => number
_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
_property: bignumber.toString() => string @SRC<bignumber:BigNumber.toString>
Returns the value of //bignumber// as a base-10 string.
_property: bignumber.toHexString() => string
_property: bignumber.toHexString() => string<[[datahexstring]]> @SRC<bignumber:BigNumber.toHexString>
Returns the value of //bignumber// as a base-16, `0x`-prefixed [hexstring](hexstring).
_heading: Inspection
_property: BigNumnber.isBigNumber(object) => boolean
_property: BigNumnber.isBigNumber(object) => boolean @SRC<bignumber>
Returns true if and only if the //object// is a BigNumber object.

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

@ -8,64 +8,77 @@ _subsection: Types
_heading: Bytes @<bytes>
A Bytes object is any object which is an
[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) or
[TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) with
A **Bytes** is any object which is an
[Array](https:/\/developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) or
[TypedArray](https:/\/developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) with
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>
A **BytesLike** can be either a [[bytes]] or a [[hexstring]].
A **BytesLike** can be either a [[bytes]] or a [[datahexstring]].
_heading: DataHexstring @<datahexstring>
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>
A **hexstring** is a string which has a ``0x`` prefix followed by
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>
- **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](https://link_here) of the **(r, s)** and **v**
- **_vs** --- The [compact representation](https://eips.ethereum.org/EIPS/eip-2098) of the **s** and **v**
- **recoveryParam** --- The normalized (i.e. 0 or 1) value of **v**
_heading: Flat-Format Signature @<signature-flat>
A **Flat-Format Signature** is a common Signature format where
the r, s and v are concanenated into a 65 byte (130 nibble)
[[datahexstring]].
_heading: SignatureLike @<signaturelike>
A **SignatureLike** is similar to a [[signature]], except redundant properties
may be omitted.
may be omitted or it may be a [[signature-flat]].
For example, if *_vs* is specified, **(r, s)** and **v** can be omitted. Likewise,
if **recoverParam** is provided, **v** can be omitted (as it can be computed).
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
missing values can be computed).
_subsection: Inspection
_property: utils.isBytes(object) => boolean
_property: utils.isBytes(object) => boolean @<utils-isbytes> @SRC<bytes>
Returns true if and only if //object// is a valid [[bytes]].
_property: utils.isBytesLike(object) => boolean
Returns true if and only if //object// is a [[bytes]] or an Array or TypedArray
where each value is a valid byte (i.e. between 0 and 255 inclusive).
_property: utils.isBytesLike(object) => boolean @<utils-isbyteslike> @SRC<bytes>
Returns true if and only if //object// is a [[bytes]] or [[datahexstring]].
_property: utils.isHexString(object, [ length ] ) => boolean
Returns true if and only if //object// is a valid hex string;
if //length// is specified the length (in bytes) is also verified.
_property: 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
//length// bytes, an InvalidArgument error is thrown.
_subsection: Converting between Arrays and Hexstrings
_property: utils.arrayify(hexstringOrArrayish [ , options ]) => Uint8Array
Converts //hexstringOrArrayish// to a Uint8Array. If a [[hexstring]]
is passed in, the length must be even.
_property: utils.arrayify(datahexstringOrArrayish [ , options ]) => Uint8Array @<utils-arrayify> @SRC<bytes>
Converts //datahexstringOrArrayish// to a Uint8Array.
_property: utils.hexlify(hexstringOrArrayish) => string
Converts //hexstringOrArrayish// to a [[hexstring]]. The result
will always be zero-padded to even length.
_property: utils.hexlify(hexstringOrArrayish) => string<[[datahexstring]]> @<utils-hexlify> @SRC<bytes>
Converts //hexstringOrArrayish// to a [[datahexstring]].
_property: utils.hexValue(aBigNumberish) => string
Converts //aBigNumberish// to a [[hexstring]], with no unecessary leading
zeros. The result of this function can be of odd-length.
_property: utils.hexValue(aBigNumberish) => string<[[hexstring]]> @<utils-hexvalue> @SRC<bytes>
Converts //aBigNumberish// to a [[hexstring]], with no __unnecessary__ leading
zeros.
_heading: Examples
@ -74,48 +87,51 @@ _code: bytes-conversion.js
_subsection: Array Manipulation
_property: utils.concat(arrayOfBytesLike) => Uint8Array
Concatenates all the [[byteslike]] in //arrayOfBytesLike//
into a single Uint8Array.
_property: utils.concat(arrayOfBytesLike) => Uint8Array @<utils-concat> @SRC<bytes>
Concatenates all the [[byteslike]] in //arrayOfBytesLike// into a single Uint8Array.
_property: utils.stripZeros(aBytesLike) => Uint8Array
Concatenates all the [[byteslike]] in //arrayOfBytesLike//
_property: utils.stripZeros(aBytesLike) => Uint8Array @<utils-stripzeros> @SRC<bytes>
Returns a Uint8Array with all leading ``0`` bytes of //aBtyesLike// removed.
_property: utils.zeroPad(aBytesLike, length) => Uint8Array
Concatenates all the [[byteslike]] in //arrayOfBytesLike//
_property: 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.
If //aBytesLike// is already longer than //length// bytes long, an InvalidArgument
error will be thrown.
_subsection: Hexstring Manipulation
_property: utils.hexConcat(arrayOfBytesLike) => string
Concatenates all the [[byteslike]] in //arrayOfBytesLike//
into a single [[hexstring]]
_property: utils.hexConcat(arrayOfBytesLike) => string<[[datahexstring]]> @<utils-hexconcat> @SRC<bytes>
Concatenates all the [[byteslike]] in //arrayOfBytesLike// into a single [[datahexstring]]
_property: utils.hexDataLength(aBytesLike) => number
_property: utils.hexDataLength(aBytesLike) => string<[[datahexstring]]> @<utils-hexdatalength> @SRC<bytes>
Returns the length (in bytes) of //aBytesLike//.
This will **throw and error** if //aBytesLike// is a [[hexstring]]
but is of odd-length.
_property: 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: utils.hexDataSlice(aBytesLike, offset [ , endOffset ] ) => string
Returns the length (in bytes) of //aBytesLike//.
_property: utils.hexStripZeros(aBytesLike) => string<[[hexstring]]> @<utils-hexstripzeros> @SRC<bytes>
Returns a [[hexstring]] representation of //aBytesLike// with all
leading zeros removed.
_property: utils.hexStripZeros(aBytesLike) => string
@TODO
_property: utils.hexZeroPad(aBytesLike, length) => string<[[datahexstring]]> @<utils-hexzeropad> @SRC<bytes>
Returns a [[datahexstring]] representation of //aBytesLike// padded to //length// bytes.
_property: utils.hexZeroPad(aBytesLike, length) => string
@TODO
If //aBytesLike// is already longer than //length// bytes long, an InvalidArgument
error will be thrown.
_subsection: Signature Conversion
_property: utils.joinSignature(aSignatureLike) => string
Return the flat-format of a [[signaturelike]], which is
65 bytes (130 nibbles) long, concatenating the **r**, **s** and **v**
of a Signature.
_property: utils.joinSignature(aSignatureLike) => string<[FlatSignature](signature-flat)> @<utils-joinsignature> @SRC<bytes>
Return the flat-format of //aSignaturelike//, which is 65 bytes (130 nibbles)
long, concatenating the **r**, **s** and (normalized) **v** of a Signature.
_property: utils.splitSignature(aSignatureLikeOrBytesLike) => Signature
Return the full expanded-format of a [[signaturelike]] or
a flat-format [[hexstring]]. Any missing properties will be
computed.
_property: utils.splitSignature(aSignatureLikeOrBytesLike) => [[signature]] @<utils-splitsignature> @SRC<bytes>
Return the full expanded-format of //aSignaturelike// or a flat-format [[datahexstring]].
Any missing properties will be computed.

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

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

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

@ -46,23 +46,23 @@ _subsection: Functions
_heading: Formatting
_property: utils.commify(value) => string
_property: utils.commify(value) => string @<util-commify> @SRC<units>
Returns a string with value grouped by 3 digits, separated by ``,``.
_heading: Conversion @<unit-conversion>
_property: utils.formatUnits(value [ , unit = "ether" ] ) => string
_property: utils.formatUnits(value [ , unit = "ether" ] ) => string @<util-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: utils.formatEther(value) => string
_property: utils.formatEther(value) => string @<util-formatether> @SRC<units>
The equivalent to calling ``formatUnits(value, "ether")``.
_property: utils.parseUnits(value [ , unit = "ether" ] ) => [BigNumber](bignumber)
_property: utils.parseUnits(value [ , unit = "ether" ] ) => [BigNumber](bignumber) @<util-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: utils.parseEther(value) => [BigNumber](bignumber)
_property: utils.parseEther(value) => [BigNumber](bignumber) @<util-parseether> @SRC<units>
The equivalent to calling ``parseUnits(value, "ether")``.

21
docs.wrm/api/utils/encoding.wrm Normal file
View File

@ -0,0 +1,21 @@
_title: Encoding Utilies
_section: Encoding Utilities
_property: utils.base58.decode(textData) => Uin8Array
Return a typed Uint8Array representation of //textData// decoded using
base-58 encoding.
_property: utils.base58.encode(aBytesLike) => string
Return //aBytesLike// encoded as a string using the base-58 encoding.
_property: utils.base64.decode(textData) => Uin8Array
Return a typed Uint8Array representation of //textData// decoded using
base-64 encoding.
_property: utils.base64.encode(aBytesLike) => string
Return //aBytesLike// encoded as a string using the base-64 encoding.

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

@ -2,12 +2,51 @@ _title: Fixed Number
_section: FixedNumber @<fixednumber>
_subsection: FixedFormat @<fixedformat>
_subsection: Types
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.
_heading: Format Strings @<fixedformatstring>
A format string is composed of three components, including signed-ness,
bit-width and number of decimals.
A signed format string begins with ``fixed``, which an unsigned format
string begins with ``ufixed``, followed by the width (in bits) and the
number of decimals.
The width must be conguent to 0 mod 8 (i.e. ``(width % 8) == 0``) and no
larger than 256 bits and the number of decimals must be no larger than 80.
For example:
- **fixed128x18** is signed, 128 bits wide and has 18 decimals; this is useful for most purposes
- **fixed32x0** is signed, 32 bits wide and has 0 decimals; this would be the same as a ``int32_t` in C
- **ufixed32x0** is unsigned, 32 bits wide and has 0 decimals; this would be the same as a ``uint32_t` in C
- **fixed** is shorthand for ``fixed128x18`
- **ufixed** is shorthand for ``ufixed128x18`
_heading: Creating Instances
_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]]
may be passed in as well as any object which has any of ``signed``, ``width`` and ``decimals``
defined, including a [[fixedformat]] object.
_heading: Properties
_property: fixedFormat.signed => boolean
_property: fixedFormat.width => number
_property: fixedFormat.decimals => number
_property: fixedFormat.name => string
_heading: FixedFormat @<fixedformat>
TODO
_definition: **//"fixed"//**
A shorthand for ``fixed128x80``.
@ -17,17 +56,17 @@ _subsection: Creating Instances
The FixedNumber constructor cannot be called directly. There are several
static methods for creating a FixedNumber.
_property: BigNumber.from(value [ , format = "fixed" ] ) => [[fixednumber]]
_property: FixedNumber.from(value [ , format = "fixed" ] ) => [[fixednumber]] @SRC<bignumber:FixedNumber.from>
Returns an instance of a **FixedNumber** for //value// as a //format//.
_property: BigNumber.fromBytes(aBytesLike [ , format = "fixed" ] ) => [[fixednumber]]
_property: FixedNumber.fromBytes(aBytesLike [ , format = "fixed" ] ) => [[fixednumber]] @SRC<bignumber>
Returns an instance of a **FixedNumber** for //value// as a //format//.
_property: BigNumber.fromString(value [ , format = "fixed" ] ) => [[fixednumber]]
_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: BigNumber.fromValue(value [ , decimals = 0 [ , format = "fixed" ] ] ) => [[fixednumber]]
_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//.
@ -41,40 +80,40 @@ _subsection: Methods
_heading: Math Operations
_property: fixednumber.addUnsafe(otherValue) => [[fixednumber]]
_property: fixednumber.addUnsafe(otherValue) => [[fixednumber]] @SRC<bignumber/fixednumber>
Returns a new FixedNumber with the value of //fixedvalue// **+** //otherValue//.
_property: fixednumber.subUnsafe(otherValue) => [[fixednumber]]
_property: fixednumber.subUnsafe(otherValue) => [[fixednumber]] @SRC<bignumber/fixednumber>
Returns a new FixedNumber with the value of //fixedvalue// **&ndash;** //otherValue//.
_property: fixednumber.mulUnsafe(otherValue) => [[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]]
_property: fixednumber.divUnsafe(otherValue) => [[fixednumber]] @SRC<bignumber/fixednumber>
Returns a new FixedNumber with the value of //fixedvalue// **&#247;** //otherValue//.
_property: fixednumber.round([ decimals = 0 ]) => [[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]]
_property: fixednumber.toFormat(format) => [[fixednumber]] @SRC<bignumber/fixednumber>
Returns a new FixedNumber with the value of //fixedvalue// with //format//.
_property: fixednumber.toHexString() => string
_property: fixednumber.toHexString() => string @SRC<bignumber/fixednumber>
Returns a [Hexstring](hexstring) representation of //fixednumber//.
_property: fixednumber.toString() => string
_property: fixednumber.toString() => string @SRC<bignumber/fixednumber>
Returns a string representation of //fixednumber//.
_property: fixednumber.toUnsafeFloat() => float
_property: fixednumber.toUnsafeFloat() => float @SRC<bignumber/fixednumber>
Returns a floating-point JavaScript number value of //fixednumber//.
Due to rounding in JavaScript numbers, the value is only approximate.
_heading: Inspection
_property: BigNumber.isFixedNumber(value) => boolean
_property: FixedNumber.isFixedNumber(value) => boolean @SRC<bignumber/fixednumber>
Returns true if and only if //value// is a **FixedNumber**.

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

@ -10,43 +10,43 @@ _subsection: Cryptographic Hashing
The [Cryptographic Hash Functions](https://en.wikipedia.org/wiki/Cryptographic_hash_function)
are a specific family of hash functions.
_property: utils.keccak256(aBytesLike) => string
_property: utils.keccak256(aBytesLike) => string<[[datahexstring]]<32>> @<utils-keccak256> @SRC<keccak256>
Returns the [KECCAK256](https://en.wikipedia.org/wiki/SHA-3) digest //aBytesLike//.
_property: utils.ripemd160(aBytesLike) => string
_property: utils.ripemd160(aBytesLike) => string<[[datahexstring]]<20>> @<utils-ripemd160> @SRC<sha2>
Returns the [RIPEMD-160](https://en.m.wikipedia.org/wiki/RIPEMD) digest of //aBytesLike//.
_property: utils.sha256(aBytesLike) => string
_property: utils.sha256(aBytesLike) => string<[[datahexstring]]<32>> @<utils-sha256> @SRC<sha2:function.sha256>
Returns the [SHA2-256](https://en.wikipedia.org/wiki/SHA-2) digest of //aBytesLike//.
_property: utils.sha512(aBytesLike) => string
_property: utils.sha512(aBytesLike) => string<[[datahexstring]]<64>> @<utils-sha512> @SRC<sha2:function.sha512>
Returns the [SHA2-512](https://en.wikipedia.org/wiki/SHA-2) digest of //aBytesLike//.
_property: utils.computeHmac(algorithm, key, data) => string
_property: utils.computeHmac(algorithm, key, data) => string<[[datahexstring]]> @<utils-computehmac> @SRC<sha2>
Returns the [HMAC](https://en.wikipedia.org/wiki/HMAC) of //data// with //key//
using the [Algorithm](supported-algorithm) //algorithm//.
_heading: HMAC Supported Algorithms @<supported-algorithm>
_heading: HMAC Supported Algorithms @<supported-algorithm> @SRC<sha2:enum.SupportedAlgorithms>
_property: utils.SupportedAlgorithms.sha256
_property: utils.SupportedAlgorithms.sha256 => string
Use the [SHA2-256](https://en.wikipedia.org/wiki/SHA-2) hash algorithm.
_property: utils.SupportedAlgorithms.sha512
_property: utils.SupportedAlgorithms.sha512 => string
Use the [SHA2-512](https://en.wikipedia.org/wiki/SHA-2) hash algorithm.
_subsection: Common Hashing Helpers
_property: utils.hashMessage(message) => string
_property: utils.hashMessage(message) => string<[[datahexstring]]<32>> @<utils-hashmessage> @SRC<hash>
Computes the Ethereum message digest of //message//. Ethereum messages are
converted to UTF-8 bytes and prefixed with ``\x19Ethereum Signed Message:``
and the length of //message//.
_property: utils.id(text) => string
_property: utils.id(text) => string<[[datahexstring]]<32>> @<utils-id> @SRC<hash>
The Ethereum Identity function computs the keccak256 hash of the //text// bytes.
_property: utils.namehash(name) => string
_property: utils.namehash(name) => string<[[datahexstring]]<32>> @<utils-namehash> @SRC<hash>
Returns the [ENS Namehash](https://docs.ens.domains/contract-api-reference/name-processing#hashing-names) of //name//.
@ -56,15 +56,15 @@ 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: utils.solidityPack(arrayOfTypes, arrayOfValues) => string
_property: 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: utils.solidityKeccak256(arrayOfTypes, arrayOfValues) => string
_property: utils.solidityKeccak256(arrayOfTypes, arrayOfValues) => string<[[datahexstring]]<32>> @<utils-soliditykeccak256> @SRC<solidity:keccak256>
Returns the KECCAK256 of the non-standard encoded //arrayOfValues// packed
according to their respective type in //arrayOfTypes//.
_property: utils.soliditySha256(arrayOfTypes, arrayOfValues) => string
_property: utils.soliditySha256(arrayOfTypes, arrayOfValues) => string<[[datahexstring]]<32>> @<utils-soliditysha256> @SRC<solidity:sha256>
Returns the SHA2-256 of the non-standard encoded //arrayOfValues// packed
according to their respective type in //arrayOfTypes//.

1
docs.wrm/api/utils/index.wrm
View File

@ -7,6 +7,7 @@ are also quite useful for application developers.
_toc:
address
abi
bignumber
bytes
constants

12
docs.wrm/api/utils/signing-key.wrm Normal file
View File

@ -0,0 +1,12 @@
_title: Signing Keys
_section: Signing Key
_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
will then be used to compute the address; this allows systems which use
the v to encode additional data (such as [EIP-155](https://eips.ethereum.org/EIPS/eip-155))
to be used since the v parameter is still completely non-ambiguous.

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

@ -17,40 +17,41 @@ single word (32 bytes). Since we need only a single byte for the
null termination, we can store strings up to 31 bytes long in a
word.
_definition: **Note:**
_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: utils.parseBytes32String(aBytesLike) => string
_property: utils.parseBytes32String(aBytesLike) => string @<utils-parsebytes32> @SRC<strings>
Returns the decoded string represented by the ``Bytes32`` encoded data.
_property: utils.formatBytes32String(text) => string
_property: 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>
_property: utils.toUtf8Bytes(text [ , form = current ] ) => Uint8Array
_property: 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//.
_property: utils.toUtf8CodePoints(aBytesLike [ , form = current ] ) => Array<number>
_property: utils.toUtf8CodePoints(aBytesLike [ , form = current ] ) => Array<number> @<utils-toutf8codepoints> @SRC<strings>
Returns the Array of codepoints of //aBytesLike//, optionally normalizing it using the
[[unicode-normalization-form]] //form//.
**Note:** This function correctly splits each user-perceived character into
_note: Note
This function correctly splits each **user-perceived character** into
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: utils.toUtf8String(aBytesLike [ , ignoreErrors = false ] ) => string
_property: utils.toUtf8String(aBytesLike [ , ignoreErrors = false ] ) => string @<utils-toutf8string> @SRC<strings>
Returns the string represented by the UTF-8 bytes of //aBytesLike//. This will
throw an error for invalid surrogates, overlong sequences or other UTF-8 issues,
unless //ignoreErrors// is specified.
_heading: UnicodeNormalizationForm @<unicode-normalization-form>
_heading: UnicodeNormalizationForm @<unicode-normalization-form> @SRC<strings/utf8:enum.UnicodeNormalizationForm>
There are several [commonly used forms](https://en.wikipedia.org/wiki/Unicode_equivalence)
when normalizing UTF-8 data, which allow strings to be compared or hashed in a stable
@ -86,7 +87,7 @@ _property: utils.UnicodeNormalizationForm.NFKD
The Decomposed Normalization Form with Canonical Equivalence.
See NFKC for more an example.
_definition: **Note:**
_note: Note
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
it should **not** be considered a method to acheive //any// level of security from
[homoglyph attacks](https://en.wikipedia.org/wiki/IDN_homograph_attack).

69
docs.wrm/cli/ens-help.txt Normal file
View File

@ -0,0 +1,69 @@
Usage:
ethers-ens COMMAND [ ARGS ] [ OPTIONS ]
COMMANDS
lookup [ NAME | ADDRESS [ ... ] ]
Lookup a name or address
commit NAME Submit a pre-commitment
[ --duration DAYS ] Register duration (default: 365 days)
[ --salt SALT ] SALT to blind the commit with
[ --secret SECRET ] Use id(SECRET) as the salt
[ --owner OWNER ] The target owner (default: current account)
reveal NAME Reveal a previous pre-commitment
[ --duration DAYS ] Register duration (default: 365 days)
[ --salt SALT ] SALT to blind the commit with
[ --secret SECRET ] Use id(SECRET) as the salt
[ --owner OWNER ] The target owner (default: current account)
set-controller NAME Set the controller (default: current account)
[ --address ADDRESS ] Specify another address
set-subnode NAME Set a subnode owner (default: current account)
[ --address ADDRESS ] Specify another address
set-resolver NAME Set the resolver (default: resolver.eth)
[ --address ADDRESS ] Specify another address
set-addr NAME Set the addr record (default: current account)
[ --address ADDRESS ] Specify another address
set-text NAME KEY VALUE Set a text record
set-email NAME EMAIL Set the email text record
set-website NAME URL Set the website text record
set-content NAME HASH Set the IPFS Content Hash
migrate-registrar NAME Migrate from the Legacy to the Permanent Registrar
transfer NAME NEW_OWNER Transfer registrant ownership
reclaim NAME Reset the controller by the registrant
[ --address ADDRESS ] Specify another address
ACCOUNT OPTIONS
--account FILENAME Load from a file (JSON, RAW or mnemonic)
--account RAW_KEY Use a private key (insecure *)
--account 'MNEMONIC' Use a mnemonic (insecure *)
--account - Use secure entry for a raw key or mnemonic
--account-void ADDRESS Use an address as a void signer
--account-void ENS_NAME Add the resolved address as a void signer
--account-rpc ADDRESS Add the address from a JSON-RPC provider
--account-rpc INDEX Add the index from a JSON-RPC provider
--mnemonic-password Prompt for a password for mnemonics
--xxx-mnemonic-password Prompt for a (experimental) hard password
PROVIDER OPTIONS (default: all + homestead)
--alchemy Include Alchemy
--etherscan Include Etherscan
--infura Include INFURA
--nodesmith Include nodesmith
--rpc URL Include a custom JSON-RPC
--offline Dump signed transactions (no send)
--network NETWORK Network to connect to (default: homestead)
TRANSACTION OPTIONS (default: query network)
--gasPrice GWEI Default gas price for transactions(in wei)
--gasLimit GAS Default gas limit for transactions
--nonce NONCE Initial nonce for the first transaction
--yes Always accept Siging and Sending
OTHER OPTIONS
--wait Wait until transactions are mined
--debug Show stack traces for errors
--help Show this usage and exit
--version Show this version and exit
(*) By including mnemonics or private keys on the command line they are
possibly readable by other users on your system and may get stored in
your bash history file. This is NOT recommended.

13
docs.wrm/cli/ens.wrm Normal file
View File

@ -0,0 +1,13 @@
_title: ENS
_section: ENS
_subsection: Help
_code: ens-help.txt
_heading: Examples
TODO examples

65
docs.wrm/cli/ethers-help.txt Normal file
View File

@ -0,0 +1,65 @@
Usage:
ethers [ COMMAND ] [ ARGS ] [ OPTIONS ]
COMMANDS (default: sandbox)
sandbox Run a REPL VM environment with ethers
init FILENAME Create a new JSON wallet
[ --force ] Overwrite any existing files
fund TARGET Fund TARGET with testnet ether
info [ TARGET ... ] Dump info for accounts, addresses and ENS names
send TARGET ETHER Send ETHER ether to TARGET form accounts[0]
[ --allow-zero ] Allow sending to the address zero
[ --data DATA ] Include data in the transaction
sweep TARGET Send all ether from accounts[0] to TARGET
sign-message MESSAGE Sign a MESSAGE with accounts[0]
[ --hex ] The message content is hex encoded
eval CODE Run CODE in a VM with ethers
run FILENAME Run FILENAME in a VM with ethers
wait HASH Wait for a transaction HASH to be mined
wrap-ether VALUE Deposit VALUE into Wrapped Ether (WETH)
unwrap-ether VALUE Withdraw VALUE from Wrapped Ether (WETH)
send-token TOKEN ADDRESS VALUE
Send VALUE tokens (at TOKEN) to ADDRESS
compile FILENAME Compiles a Solidity contract
[ --no-optimize ] Do not optimize the compiled output
[ --warnings ] Error on any warning
deploy FILENAME Compile and deploy a Solidity contract
[ --no-optimize ] Do not optimize the compiled output
[ --contract NAME ] Specify the contract to deploy
ACCOUNT OPTIONS
--account FILENAME Load from a file (JSON, RAW or mnemonic)
--account RAW_KEY Use a private key (insecure *)
--account 'MNEMONIC' Use a mnemonic (insecure *)
--account - Use secure entry for a raw key or mnemonic
--account-void ADDRESS Use an address as a void signer
--account-void ENS_NAME Add the resolved address as a void signer
--account-rpc ADDRESS Add the address from a JSON-RPC provider
--account-rpc INDEX Add the index from a JSON-RPC provider
--mnemonic-password Prompt for a password for mnemonics
--xxx-mnemonic-password Prompt for a (experimental) hard password
PROVIDER OPTIONS (default: all + homestead)
--alchemy Include Alchemy
--etherscan Include Etherscan
--infura Include INFURA
--nodesmith Include nodesmith
--rpc URL Include a custom JSON-RPC
--offline Dump signed transactions (no send)
--network NETWORK Network to connect to (default: homestead)
TRANSACTION OPTIONS (default: query network)
--gasPrice GWEI Default gas price for transactions(in wei)
--gasLimit GAS Default gas limit for transactions
--nonce NONCE Initial nonce for the first transaction
--yes Always accept Siging and Sending
OTHER OPTIONS
--wait Wait until transactions are mined
--debug Show stack traces for errors
--help Show this usage and exit
--version Show this version and exit
(*) By including mnemonics or private keys on the command line they are
possibly readable by other users on your system and may get stored in
your bash history file. This is NOT recommended.

14
docs.wrm/cli/ethers-init.txt Normal file
View File

@ -0,0 +1,14 @@
/home/ethers> ethers init wallet.json
Creating a new JSON Wallet - wallet.json
Keep this password and file SAFE!! If lost or forgotten
it CANNOT be recovered, by ANYone, EVER.
Choose a password: ******
Confirm password: ******
Encrypting... 100%
New account address: 0x485bcC23ae2E5038ec7ec9b8DCB2A6A6291cC003
Saved: wallet.json
# If you are planning to try out the Ropsten testnet...
/home/ethers> ethers --network ropsten fund 0x485bcC23ae2E5038ec7ec9b8DCB2A6A6291cC003
Transaction Hash: 0x8dc55b8f8dc8076acded97f9e3ed7d6162460c0221e2769806006b6d7d1156e0

8
docs.wrm/cli/ethers-mnemonic-hard.txt Normal file
View File

@ -0,0 +1,8 @@
/home/ricmoo> ethers --account mnemonic.txt --xxx-mnemonic-password
Password (mnemonic; experimental - hard): ******
Decrypting... 100%
network: homestead (chainId: 1)
homestead> accounts[0].getAddress()
<Promise id=0 resolved>
'0x56FC8792cC17971C19bEC4Ced978beEA44711EeD'
homestead>

7
docs.wrm/cli/ethers-mnemonic.txt Normal file
View File

@ -0,0 +1,7 @@
/home/ricmoo> ethers --account public-mnemonic.txt --mnemonic-password
Password (mnemonic): ******
network: homestead (chainId: 1)
homestead> accounts[0].getAddress()
<Promise id=0 resolved>
'0x6d3F723EC1B73141AA4aC248c3ab34A5a1DAD776'
homestead>

19
docs.wrm/cli/ethers-script.txt Normal file
View File

@ -0,0 +1,19 @@
# Get the formatted balance of an account
/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()"
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"}]}
# Compute a topic hash
/home/ricmoo> ethers eval 'id("Transfer(address,address,uint256")'
0xd99659a21de82e379975ce8df556f939a4ccb95e92144f38bb0dd35730ffcdd5
# Create a random mnemonic
/home/ricmoo> ethers eval 'Wallet.createRandom().mnemonic'
useful pond inch knock ritual matrix giggle attend dilemma convince coach amazing

44
docs.wrm/cli/ethers-send.txt Normal file
View File

@ -0,0 +1,44 @@
# Sending ether
/home/ricmoo> ethers --account wallet.json send ricmoo.firefly.eth 0.123
Password (wallet.json): ******
Decrypting... 100%
Transaction:
To: 0x8ba1f109551bD432803012645Ac136ddd64DBA72
From: 0xaB7C8803962c0f2F5BBBe3FA8bf41cd82AA1923C
Value: 0.123 ether
Nonce: 96
Data: 0x
Gas Limit: 21000
Gas Price: 1.2 gwei
Chain ID: 1
Network: homestead
Send Transaction? (y/N/a) y
Response:
Hash: 0xc4adf8b379033d7ab679d199aa35e6ceee9a802ca5ab0656af067e911c4a589a
# Sending a token (SAI)
# NOTE: the contract address could be used instead but
# popular token contract addresses are also managed
# by ethers
/home/ricmoo> ethers --account wallet.json send-token sai.tokens.ethers.eth ricmoo.firefly.eth 1.0
Sending Tokens:
To: 0x8ba1f109551bD432803012645Ac136ddd64DBA72
Token Contract: 0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359
Value: 1.0
Password (wallet.json): ******
Decrypting... 100%
Transaction:
To: 0x89d24A6b4CcB1B6fAA2625fE562bDD9a23260359
From: 0xaB7C8803962c0f2F5BBBe3FA8bf41cd82AA1923C
Value: 0.0 ether
Nonce: 95
Data: 0xa9059cbb0000000000000000000000008ba1f109551bd432803012645ac136ddd64dba720000000000000000000000000000000000000000000000000de0b6b3a7640000
Gas Limit: 37538
Gas Price: 1.0 gwei
Chain ID: 1
Network: homestead
Send Transaction? (y/N/a) y
Response:
Hash: 0xd609ecb7e3b5e8d36fd781dffceede3975ece6774b6322ea56cf1e4d0a17e3a1

14
docs.wrm/cli/ethers-sign.txt Normal file
View File

@ -0,0 +1,14 @@
/home/ethers> ethers --account wallet.json sign-message 'Hello World'
Password (wallet.json): ******
Decrypting... 100%
Message:
Message: "Hello World"
Message (hex): 0x48656c6c6f20576f726c64
Sign Message? (y/N/a) y
Signature
Flat: 0xca3f0b32a22a5ab97ca8be7e4a36b1e81d565c6822465d769f4faa4aa24539fb122ee5649c8a37c9f5fc8446593674159e3a7b039997cd6ee697a24b787b1a161b
r: 0xca3f0b32a22a5ab97ca8be7e4a36b1e81d565c6822465d769f4faa4aa24539fb
s: 0x122ee5649c8a37c9f5fc8446593674159e3a7b039997cd6ee697a24b787b1a16
vs: 0x122ee5649c8a37c9f5fc8446593674159e3a7b039997cd6ee697a24b787b1a16
v: 27
recid: 0

59
docs.wrm/cli/ethers.wrm Normal file
View File

@ -0,0 +1,59 @@
_title: Sandbox Utility
_section: Sandbox Utility
The sandbox utility provides a simple way to use the most common
ethers utilities required during learning, debuging and managing
interactions with the Ethereum network.
If no command is given, it will enter a REPL interface with many
of the ethers utilities already exposed.
_subsection: Help
_code: ethers-help.txt
_subsection: Examples
_heading: Creating Wallets @<cliex-init>
_code: ethers-init.txt
_heading: Sending Ether and Tokens @<cliex-send>
_code: ethers-send.txt
_heading: Signing Messages @<cliex-signing>
_code: ethers-sign.txt
_heading: Scripting @<cliex-scripting>
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: ethers-script.txt
_heading: Using Mnemonics (with a password) @<cliex-mnemonicpassword>
All mnemonic phrases have a password, but the default is to use the empty
string (i.e. ``""``) as the password. If you have a password on your
mnemonic, the ``-\-mnemonic-password`` will prompt for the password to
use to decrypt the account.
_code: ethers-mnemonic.txt
_heading: Using Mnemonics (with experimental memory-hard passwords) @<cliex-mnemonicpassword-xxx>
The ``-\-xxx-mnemonic-password`` is similar to the ``-\-mnemonic-password`` options,
which uses a password to decrypt the account for a mnemonic, however it passes
the password through the [scrypt](https:/\/en.wikipedia.org/wiki/Scrypt)
//password-based key derivation function// first, which is intentionally slow and makes
a brute-force attack far more difficult.
_code: ethers-mnemonic-hard.txt
_warning: Note
This is still an experimental feature (hence the ``xxx``).

9
docs.wrm/cli/index.wrm Normal file
View File

@ -0,0 +1,9 @@
_title: Command Line Interfaces
_section: Command Line Interfaces
_toc:
ethers
ens
typescript
plugin

10
docs.wrm/cli/plugin.txt Normal file
View File

@ -0,0 +1,10 @@
/home/ethers> ethers --account wallet.json --yes send ricmoo.eth 1.0
# An Option ----------^ ^ ^
# - name = "account" | |
# - value = "wallet.json" | |
# A Flag -----------------------------------+ |
# - name = "yes" |
# - value = true |
# Arguments ------------------------------------+
# - count = 3
# - [ "send", "ricmoo.eth", "1.0" ]

148
docs.wrm/cli/plugin.wrm Normal file
View File

@ -0,0 +1,148 @@
_title: Making Your Own
_section: Making Your Own
The //cli// library is meant to make it easy to create command
line utilities of your own.
_subsection: CLI @<cli-cli> @SRC<cli:class.CLI>
A **CLI** handles parsing all the command-line flags, options and arguments
and instantiates a [[cli-plugin]] to process the command.
A **CLI** may support multiple [[cli-plugin]]'s in which case the first
argument is used to determine which to run (or if no arguments, the default
plugin will be selected) or may be designed to be standalone, in which case
exactly one [[cli-plugin]] will be used and no command argument is allowed.
_property: addPlugin(command, pluginClass) => void @<cli-addplugin> @SRC<cli/cli>
Add a //plugin// class for the //command//. After all options and flags
have been consumed, the first argument will be consumed and the
associated plugin class will be instantiated and run.
_property: setPlugin(pluginClass) => void @<cli-setplugin> @SRC<cli/cli>
Set a dedicated [[cli-plugin]] class which will handle all input. This
may not be used in conjuction with addPlugin and will not automatically
accept a command from the arguments.
_property: showUsage([ message = "" [ , status = 0 ] ]) => never @<cli-showusage> @SRC<cli/cli>
Shows the usage help screen for the CLI and terminates.
_property: run(args) => Promise<void> @<cli-run> @SRC<cli/cli:CLI.run>
Usually the value of //args// passed in will be ``process.argv.slice(2)``.
_subsection: Plugin @<cli-plugin> @SRC<cli:class.Plugin>
Each **Plugin** manages each command of a CLI and is executed in phases.
If the usage (i.e. help) of a CLI is requested, the static methods ``getHelp``
and ``getOptionHelp`` are used to geneate the help screen.
Otherwise, a plugin is instantiated and the ``prepareOptions`` is called. Each
plugin **must** call ``super.prepareOptions``, otherwise the basic options are
not yet processed. During this time a Plugin should consume all the flags and
options it understands, since any left over flags or options will cause the
CLI to bail and issue an //unknown option// error. This should throw if a value
for a given option is invalid or some combination of options and flags is not
allowed.
Once the prepareOptions is complete (the returned promise is resolved), the ``prepareArguments``
is called. This should validate the number of arguments is expected and throw
and error if there are too many or too few arguments or if any arguments do not
make sense.
Once the prepareArguments is complete (the returned promise is resolved), the ``run``
is called.
_property: plugin.network => [[provider-network]]
The network this plugin is running for.
_property: plugin.provider => [[provider]]
The provider for this plugin is running for.
_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]]
The gas limit this plugin should use. This is null if unspecified.
_property: plugin.gasPrice => [[bignumber]]
The gas price this plugin should use. This is null if unspecified.
_property: plugin.nonce => number
The initial nonce for the account this plugin should use.
_heading: Methods
_property: plugin.prepareOptions(argParser [ , verifyOnly = false ]) => Promise<void> @<plugin-prepareoptions> @SRC<cli/cli:Plugin.prepareOptions>
_property: plugin.prepareArgs(args) => Promise<void> @<plugin-prepareargs> @SRC<cli/cli>
_property: plugin.run() => Promise<void> @<plugin-run> @SRC<cli/cli:Plugin.run>
_property: plugin.getAddress(addressOrName [ , message = "", [ allowZero = false ] ]) => Promise<string> @<plugin-getaddress> @SRC<cli/cli:Plugin.getAddress>
A plugin should use this method to resolve an address. If the resovled address is
the zero address and //allowZero// is not true, an error is raised.
_property: plugin.dump(header, info) => void @<plugin-dump> @SRC<cli/cli:Plugin.dump>
Dumps the contents of //info// to the console with a //header// in a nicely
formatted style. In the future, plugins may support a JSON output format
which will automatically work with this method.
_property: plugin.throwUsageError([ message = "" ]) => never @<plugin-throwusageerror> @SRC<cli/cli>
Stops exectuion of the plugin and shows the help screen of the plugin with
the optional //message//.
_property: plugin.throwError(message) => never @<plugin-throwerror> @SRC<cli/cli>
Stops execution of the plugin and shows //message//.
_heading: Static Methods
_property: Plugin.getHelp => Help @<plugin-gethelp> @SRC<cli/cli>
Each subclass should implement this static method which is used to
generate the help screen.
_property: Plugin.getOptionHelp => Array<Help> @<plugin-getoptionshelp> @SRC<cli/cli>
Each subclass should implement this static method if it supports
additional options which is used to generate the help screen.
_subsection: ArgParser @<cli-argparser> @SRC<cli:class.ArgParser>
The **ArgParser** is used to parse a command line into flags, options
and arguments.
_code: plugin.txt
Flags are simple binary options (such as the ``--yes``), which are true if present
otherwise false.
Options require a single parameter follow them on the command line
(such as ``--account wallet.json``, which nhas the name ``account`` and the value
``wallet.json``)
Arguments are all other values on the command line, and are not accessed through
the **ArgParser** directly.
When a CLI is run, an **ArgParser** is used to validate the command line by using
prepareOptions, which consumes all flags and options leaving only the arguments
behind, which are then passed into prepareArgs.
_property: argParser.consumeFlag(name) => boolean @<argparser-consumeflag> @SRC<cli/cli>
Remove the flag //name// and return true if it is present.
_property: argParser.consumeMultiOptions(names) => Array<{ name: string, value: string}> @<argparser-consumemultioptions> @SRC<cli/cli>
Remove all options which match any name in the Array of //names//
with their values returning the list (in order) of values.
_property: argParser.consumeOption(name) => string @<argparser-consumeoption> @SRC<cli/cli>
Remove the option with its value for //name// and return the value. This
will throw a UsageError if the option is included multiple times.
_property: argParser.consumeOptions(name) => Array<string> @<argparser-consumeoptions> @SRC<cli/cli>
Remove all options with their values for //name// and return the list
(in order) of values.

19
docs.wrm/cli/typescript-help.txt Normal file
View File

@ -0,0 +1,19 @@
Usage:
ethers-ts FILENAME [ ... ] [ OPTIONS ]
OPTIONS
--output FILENAME Write the output to FILENAME (default: stdout)
--force Overwrite files if they already exist
--no-optimize Do not run the solc optimizer
--no-bytecode Do not include bytecode and Factory methods
OTHER OPTIONS
--debug Show stack traces for errors
--help Show this usage and exit
--version Show this version and exit
(*) By including mnemonics or private keys on the command line they are
possibly readable by other users on your system and may get stored in
your bash history file. This is NOT recommended.

11
docs.wrm/cli/typescript.wrm Normal file
View File

@ -0,0 +1,11 @@
_title: TypeScript
_section: TypeScript
_subsection: Help
_code: typescript-help.txt
_subsection: Examples
TODO

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

@ -3,3 +3,7 @@ _title: Events
_section: Events
Explain how topics and such work
_subsection: Solidity Topics
How to compute the topic...

5
docs.wrm/concepts/gas.wrm
View File

@ -1,6 +1,8 @@
_title: Gas
_section: Gas
_section: Gas @<gas>
Explain attack vectors
_subsection: Gas Price @<gas-price>
@ -10,4 +12,3 @@ processed.
_subsection: Gas Limit @<gas-limit>

3
docs.wrm/concepts/index.wrm
View File

@ -3,7 +3,8 @@ _title: Concepts
_section: Concepts
This is a very breif overview of some aspects of //Ethereum//
which developers can make use of or should be aware of.
and blockchains which developers can make use of or should
be aware of.
_toc:
events

129
docs.wrm/config.js Normal file
View File

@ -0,0 +1,129 @@
"use strict";
const { resolve } = require("path");
const fs = require("fs");
const ts = require("typescript");
function getDefinitions(source) {
const sourceFile = ts.createSourceFile("filename.ts", source);
const defs = [ ];
function add(type, name, pos) {
const lineNo = sourceFile.getLineAndCharacterOfPosition(pos).line + 1;
name = type + "." + name
defs.push({ type, name, lineNo });
}
let lastClass = null, lastEnum = null;
function visit(node, depth) {
if (ts.isConstructorDeclaration(node)) {
add("constructor", lastClass, node.body.pos);
} else if (ts.isFunctionDeclaration(node)) {
add("function", node.name.text, node.name.end);
} else if (ts.isConstructorDeclaration(node)) {
add("constructor", lastClass, node.pos);
} else if (ts.isClassDeclaration(node)) {
lastClass = node.name.escapedText;
add("class", lastClass, node.name.end);
} else if (ts.isMethodDeclaration(node)) {
if (lastClass == null) { throw new Error("missing class"); }
if (ts.hasStaticModifier(node)) {
add("staticmethod", (lastClass + "." + node.name.text), node.name.end);
} else {
add("method", (lastClass + "." + node.name.text), node.name.end);
}
} else if (ts.isEnumDeclaration(node)) {
lastEnum = node.name.escapedText;
add("enum", lastEnum, node.name.end);
} else if (ts.isEnumMember(node)) {
add("enum", (lastEnum + "." + node.name.escapedText), node.name.end);
} else if (ts.isVariableDeclaration(node)) {
if (depth === 3) {
add("var", node.name.escapedText, node.name.end);
}
}
ts.forEachChild(node, (node) => { return visit(node, depth + 1); });
}
visit(sourceFile, 0);
return defs;
}
const getSourceUrl = (function(path, include, exclude) {
console.log("Scanning TypeScript Sources...");
const Link = "https://github.com/ethers-io/ethers.js/blob/ethers-v5-beta/packages$FILENAME#L$LINE";
const Root = resolve(__dirname, path);
const readdir = function(path) {
if (path.match(exclude)) { return [ ]; }
const stat = fs.statSync(path);
if (stat.isDirectory()) {
return fs.readdirSync(path).reduce((result, filename) => {
readdir(resolve(path, filename)).forEach((file) => {
result.push(file);
});
return result;
}, [ ]);
}
if (path.match(include)) {
const source = fs.readFileSync(path).toString();
return [ { filename: path.substring(Root.length), defs: getDefinitions(source) } ]
}
return [ ];
}
const defs = readdir(Root);
return function getSourceUrl(key) {
const comps = key.split(":");
if (comps.length !== 2) { throw new Error("unsupported key"); }
const pathCheck = new RegExp("(^|[^a-zA-Z0-9_])" + comps[0].split("/").join("/(.*/)*") + "($|[^a-zA-Z0-9_])");
let match = comps[1];
if (match.indexOf("(" /* fix: )*/)) {
match = new RegExp("(^|\\.)" + match.split("(" /* fix: ) */)[0] + "$");
} else if (match[0] === "=") {
match = new RegExp("^" + match.substring(1) + "$");
} else {
match = new RegExp("(^|\\.)" + match + "$");
}
const result = [ ];
defs.forEach((def) => {
if (!def.filename.match(pathCheck)) { return; }
def.defs.forEach((d) => {
if (!d.name.match(match)) { return; }
result.push({ filename: def.filename, lineNo: d.lineNo });
});
});
if (result.length > 1) {
throw new Error(`Amibguous TypeScript link: ${ key } in [ ${ result.map((r) => JSON.stringify(r.filename + ":" + r.lineNo)).join(", ") }]`);
} else if (result.length === 0) {
throw new Error(`No matching TypeScript link: ${ key }`);
}
return Link
.replace("$LINE", String(result[0].lineNo))
.replace("$FILENAME", result[0].filename);
}
})("../packages/", new RegExp("packages/.*/src.ts/.*\.ts$"), new RegExp("/node_modules/|src.ts/.*browser.*"));
module.exports = {
title: "ethers",
foo: "Bat",
subtitle: "v5.0-beta",
logo: "logo.svg",
link: "https://docs-beta.ethers.io",
markdown: {
"banner": "-----\n\nDocumentation: [html](https://docs-beta.ethers.io/)\n\n-----\n\n"
},
getSourceUrl: getSourceUrl
};

6
docs.wrm/config.json
View File

@ -5,5 +5,11 @@
"link": "https://docs-beta.ethers.io",
"markdown": {
"banner": "-----\n\nDocumentation: [html](https://docs-beta.ethers.io/)\n\n-----\n\n"
},
"source": {
"path": "../packages/",
"include": "packages/.*/src.ts/",
"exclude": "/node_modules/|src.ts/.*browser.*",
"link": "https://github.com/ethers-io/ethers.js/blob/ethers-v5-beta/packages$FILENAME#L$LINE"
}
}

9
docs.wrm/documentation/examples.txt
View File

@ -18,6 +18,13 @@ _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
_definition and reset the indentation.

4
docs.wrm/documentation/fragment.txt
View File

@ -1,7 +1,9 @@
_DIRECTIVE: VALUE @<LINK>
_DIRECTIVE: VALUE @<LINK> @META<PARAMETER>
BODY
DIRECTIVE: The directive name
VALUE: Optional; the value to pass to the directive
LINK: Optional; a name for internal linking
META: Optional; extended directive functionality
PARAMETER: Optional; value to pass to extended directive functions
BODY: Optional; the directive body (certain directives only)

45
docs.wrm/documentation/index.wrm
View File

@ -10,7 +10,7 @@ A lot of its inspiration came from [Read the Docs](https://github.com/readthedoc
the [Sphinx](https://www.sphinx-doc.org/) project.
_subsection: Fragments
_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
@ -49,6 +49,12 @@ _definition: **_property:** //SIGNATURE//
A //property// has its JavaScript **SIGNATURE** formatted and the
markdown body is indented.
_definition: **_note:** //TITLE//
A //note// is placed in a blue bordered-box to draw attention to it.
_definition: **_warning:** //TITLE//
A //warning// is placed in an orange bordered-box to draw attention to it.
_definition: **_code:** //FILENAME//
A //code// reads the **FILENAME** and depending on the extension
adjusts it.
@ -73,7 +79,6 @@ _heading: Examples
_code: examples.txt
_subsection: Markdown @<flatworm-markdown>
The markdown is simple and does not have the flexibility of
@ -83,3 +88,39 @@ supporting [links](flatworm-markdown) and lists.
_code: markdown.txt
_subsection: Configuration @<flatworm-config>
Configuration is optional (but highly recommended) and may be either
a simple JSON file (config.json) or a JS file (config.js) placed in
the top of the source folder.
TODO: example JSON and example JS
_subsection: Extended Directive Functions @<flatworm-extended-directive-functions>
_heading: @INHERIT\<markdown>
Adds an inherits description to a directive. The //markdown// may contain links.
This extended directive function is available for:
- _section
- _subsetion
- _heading
_heading: @SRC\<text>
Calls the configuration ``getSourceUrl(text, 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.
This extended directive function is available for:
- _section
- _subsetion
- _heading
- _property

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

@ -23,7 +23,7 @@ _code: importing-node.source
_heading: Web Browser
It is generally better practice (for security reasons) to copy the
[ethers library](https://cdn.ethers.io/lib/ethers-5.0.min.js) to
[ethers library](https://cdn.ethers.io/lib/ethers-5.0.esm.min.js) to
your own webserver and serve it yourself.
For quick demos or prototyping though, it can be loaded in your

58
docs.wrm/hacking.wrm Normal file
View File

@ -0,0 +1,58 @@
_title: Hacking
_section: Hacking
Things to keep in mind:
_heading: Supported Platforms
...
_heading: Dependencies
Adding a dependency is non-trivial and will require fairly convincing
arguments.
Further, **ALL** dependencies for ethers, **must** be MIT licensed or
public domain (CC0).
All contributions to ethers are then included under the MIT license.
_heading: Printable ASCII (7-bit) Characters
All source and documentation files should ONLY use the printable ASCII
set.
This is for several reasons, bu...
- Transmission over certain HTTP servers and proxies can mangle
UTF-8 data
- Certain editors on some platforms, or in certain terminals cannot
handle UTF-8 characters elegantly
- The ability to enter non-ASCII characters on some platforms require
special keyboards, input devices or input methods to be installed,
which either not be supported, or may require administrative
priviledges.
_heading: License
MIT...
_heading: Other Considerations
A common argument to Pull Requests is that they are simple, backwards compatible
and
It is important to remember that a small change is something that
we are required to support in perpetuity.
For example, adding support for an obscure platform, such as adding a dot-file
to the root of the package, now carries the implication that we will continue
keeping that dot-file up-to-date as new versions of that platform are released.

2
docs.wrm/importing-browser.txt
View File

@ -1,2 +1,2 @@
<script src="https://cdn.ethers.io/lib/ethers-5.0.min.js"
<script src="https://cdn.ethers.io/lib/ethers-5.0.esm.min.js"
type="application/javascipt"></script>

1
docs.wrm/index.wrm
View File

@ -42,6 +42,7 @@ _toc:
getting-started
concepts
api
cli
cookbook
migration
testing

4
docs/README.md
View File

@ -45,6 +45,7 @@ Developer Documentation
* [Importing](getting-started)
* [Concepts](concepts)
* [Events](concepts/events)
* [Solidity Topics](concepts/events)
* [Gas](concepts/gas)
* [Gas Price](concepts/gas)
* [Gas Limit](concepts/gas)
@ -73,6 +74,7 @@ Developer Documentation
* [InfuraProvider](api/providers/api-providers)
* [NodesmithProvider](api/providers/api-providers)
* [AlchemyProvider](api/providers/api-providers)
* [CloudfrontProvider](api/providers/api-providers)
* [Other Providers](api/providers/other)
* [FallbackProvider](api/providers/other)
* [IpcProvider](api/providers/other)
@ -141,4 +143,4 @@ older versions of the library.
-----
**Content Hash:** 6abeb4fa3f15b3443d89a26a6b0320f602a12368bc5ebbfb14a6cce682836167
**Content Hash:** f1da4df3feeb06a567657ae41d8498ea3315f68d05dc2f9e86c2858b5d2b2f89

3
docs/api/README.md
View File

@ -36,6 +36,7 @@ Here...
* [InfuraProvider](providers/api-providers)
* [NodesmithProvider](providers/api-providers)
* [AlchemyProvider](providers/api-providers)
* [CloudfrontProvider](providers/api-providers)
* [Other Providers](providers/other)
* [FallbackProvider](providers/other)
* [IpcProvider](providers/other)
@ -80,4 +81,4 @@ Here...
-----
**Content Hash:** cbd0b8ac4ada4bfee211c0553ac53e171a6900127d874743a0dedf7fa30618f3
**Content Hash:** 82f760f38f47d32016d3fca512c5dc75539d885d13138f1faa15f4be82edf8aa

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

File diff suppressed because one or more lines are too long

6
docs/api/index.html
View File

File diff suppressed because one or more lines are too long

3
docs/api/providers/README.md
View File

@ -73,6 +73,7 @@ Provider Documentation
* [InfuraProvider](api-providers)
* [NodesmithProvider](api-providers)
* [AlchemyProvider](api-providers)
* [CloudfrontProvider](api-providers)
* [Other Providers](other)
* [FallbackProvider](other)
* [IpcProvider](other)
@ -84,4 +85,4 @@ Provider Documentation
-----
**Content Hash:** b15d8a2febb07abbbd784242c47575fbbb097f24643997ce30625c2e88adb095
**Content Hash:** 4bae65aa1521a7ecf045f950c9a702ad597d83095d079e66a5abbd327373877c

38
docs/api/providers/api-providers/README.md
View File

@ -24,30 +24,58 @@ EtherscanProvider
-----------------
Tra la la...
The **EtherscanProvider** is backed by a combination of the various
[Etherscan APIs](https://etherscan.io/apis).
#### *provider* . **getHistory** ( address ) **=>** *Array< History >*
InfuraProvider
--------------
Tra la la...
The **InfuraProvider** is backed by the popular [INFURA](https://infura.io)
Ethereum service.
It supports Mainnet (homestead) and all common testnets (Ropsten, Rinkeby,
G&ouml;rli and Kovan).
NodesmithProvider
-----------------
Tra la la...
The **NodesmithProvider** is backed by [Nodesmith](https://nodesmith.io).
It supports Mainnet (homestead) and all common testnets (Ropsten, Rinkeby,
G&ouml;rli and Kovan), as well as the Ethereum-like network [Aion](https://aion.network).
AlchemyProvider
---------------
Tra la la...
The **AlchemtProvider** is backed by [Alchemy](https://alchemyapi.io).
It supports Mainnet (homestead) and all common testnets (Ropsten, Rinkeby,
G&ouml;rli and Kovan).
CloudfrontProvider
------------------
The CloudfrontProvider is backed by the
[Cloudflare Ethereum Gateway](https://developers.cloudflare.com/distributed-web/ethereum-gateway/).
It only supports Mainnet (homestead).
-----
**Content Hash:** 9669eaaa1c2e9a31256fdd49e1b7f79550f064056b1bfd67a8cef6c7b5f8d473
**Content Hash:** 2e1dfa80bd4ab1ba02610654b00ee4250a89758a496670822e7950d5db449b1c

23
docs/api/providers/api-providers/index.html
View File

File diff suppressed because one or more lines are too long

12
docs/api/providers/index.html
View File

File diff suppressed because one or more lines are too long

16
docs/api/providers/jsonrpc-provider/index.html
View File

File diff suppressed because one or more lines are too long

18
docs/api/providers/other/index.html
View File

File diff suppressed because one or more lines are too long

26
docs/api/providers/provider/README.md
View File

File diff suppressed because one or more lines are too long

76
docs/api/providers/provider/index.html
View File

File diff suppressed because one or more lines are too long

36
docs/api/providers/types/index.html
View File

File diff suppressed because one or more lines are too long

11
docs/api/signer/README.md
View File

@ -17,7 +17,7 @@ Signer
#### *signer* . **connect** ( provider ) **=>** *Signer*
#### *signer* . **connect** ( provider ) **=>** *[Signer](./)*
TODO
@ -28,14 +28,14 @@ TODO
#### *signer* . **getBalance** ( [ blockTag="latest" ] ) **=>** *Promise(BigNumber)*
#### *signer* . **getBalance** ( [ blockTag="latest" ] ) **=>** *Promise< [BigNumber](../utils/bignumber) >*
TODO
#### *signer* . **getTransactionCount** ( [ blockTag="latest" ] ) **=>** *Promise(number)*
#### *signer* . **getTransactionCount** ( [ blockTag="latest" ] ) **=>** *Promise< number >*
TODO
@ -46,7 +46,8 @@ Wallet inherits Signer
----------------------
Wallet is...
The Wallet class inherits [Signer](./) and can sign transactions and messages
using a private key as a standard Externally Owned Account (EOA).
### Creating an Instance
@ -69,4 +70,4 @@ TODO
-----
**Content Hash:** 08ec198fa4ab407a1bed0a705073d7f40a6c3969b8e922961939fd8e009ca1ed
**Content Hash:** 62c0d9640e683e41970dc1c779bd3b59ed08c27d99e15f6b51e7bae31ac1975e

24
docs/api/signer/index.html
View File

File diff suppressed because one or more lines are too long

19
docs/api/utils/address/README.md
View File

@ -11,7 +11,7 @@ Addresses
Explain addresses,formats and checksumming here.
Also see: [Constants.AddressZero](../constants)
Also see: [constants.AddressZero](../constants)
### Functions
@ -20,32 +20,39 @@ Also see: [Constants.AddressZero](../constants)
#### *utils* . **getAddress** ( address ) **=>** *string*
TODO
Returns *address* as a Checksum Address.
If *address* is an invalid 40-nibble [Hexstring](../bytes) 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.
#### *utils* . **isAddress** ( address ) **=>** *boolean*
TODO
Returns true if *address* is valid (in any supported format).
#### *utils* . **getIcapAddress** ( address ) **=>** *string*
TODO
Returns *address* as an ICAP address. Supports the same restrictions as
[utils.getAddress](./).
#### *utils* . **getContractAddress** ( transaction ) **=>** *string*
TODO
Returns the contract address that would result if *transaction* was
used to deploy a contract.
-----
**Content Hash:** 0e138a3fe39efa87749ebc8290d153f705d26e547a38b7dce5f4d85603264d24
**Content Hash:** 2dd561245955594d7080796077503064181258304572112d320139ae2594f383

16
docs/api/utils/address/index.html
View File

File diff suppressed because one or more lines are too long

56
docs/api/utils/bignumber/README.md
View File

@ -108,44 +108,7 @@ Returns an instance of a **BigNumber** for *aBigNumberish*.
```javascript
// From a decimal string...
BigNumber.from("42")
// { BigNumber: "42" }
// From a hexstring...
BigNumber.from("0x2a")
// { BigNumber: "42" }
// From a negative hexstring...
BigNumber.from("-0x2a")
// { BigNumber: "-42" }
// From an Array (or Uint8Array)...
BigNumber.from([ 42 ])
// { BigNumber: "42" }
// From an existing BigNumber...
let one1 = constants.One;
let one2 = BigNumber.from(one1)
one2
// { BigNumber: "1" }
// ...which returns the same instance
one1 === one2
// true
// From a (safe) number...
BigNumber.from(42)
// { BigNumber: "42" }
// From a ES2015 BigInt... (only on platforms with BigInt support)
BigNumber.from(42n)
// { BigNumber: "42" }
// Numbers outside the safe range fail:
BigNumber.from(Number.MAX_SAFE_INTEGER);
// Error: overflow (fault="overflow", operation="BigNumber.from", value=9007199254740991, version=bignumber/5.0.0-beta.129)
Skipping JavaScript Evaluation.
```
@ -223,9 +186,9 @@ the *bitcount* least significant bits set to zero.
[Two's Complicment](https://en.wikipedia.org/wiki/Two%27s_complement)
is a method used to encode and decode fixed-width values which can be
positive or negative, without requiring a separate sign bit. Most users
will not need to interact with these.
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.
#### *bignumber* . **fromTwos** ( bitwidth ) **=>** *[BigNumber](./)*
@ -333,11 +296,7 @@ Returns true if and only if the *object* is a BigNumber object.
```javascript
let a = BigNumber.from(42);
let b = BigNumber.from("91");
a.mul(b);
// { BigNumber: "3822" }
Skipping JavaScript Evaluation.
```
@ -369,8 +328,7 @@ To demonstrate how this may be an issue in your code, consider:
```javascript
(Number.MAX_SAFE_INTEGER + 2 - 2) == (Number.MAX_SAFE_INTEGER)
// false
Skipping JavaScript Evaluation.
```
@ -386,4 +344,4 @@ mathematical operations handled safely.
-----
**Content Hash:** 269c8464ff80c77316617cbfa4e9a195d742f829a23911fecf0bba16961f81ae
**Content Hash:** 76be4f72801f0d772c1ebe1acff4c41f6d52ed96f603de4b168f12d099470273

96
docs/api/utils/bignumber/index.html
View File

File diff suppressed because one or more lines are too long

129
docs/api/utils/bytes/README.md
View File

@ -20,7 +20,7 @@ Types
### Bytes
A Bytes object is any object which is an
A **Bytes** is any object which is an
[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array) or
[TypedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) with
each value in the valid byte range (i.e. between 0 and 255 inclusive),
@ -31,13 +31,22 @@ is in the valid byte range.
### BytesLike
A **BytesLike** can be either a [Bytes](./) or a [Hexstring](./).
A **BytesLike** can be either a [Bytes](./) or a [DataHexstring](./).
### DataHexstring
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.
### Hexstring
A **hexstring** is a string which has a `0x` prefix followed by
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`).
### Signature
@ -57,8 +66,9 @@ A **hexstring** is a string which has a `0x` prefix followed by
A **SignatureLike** is similar to a [Signature](./), except redundant properties
may be omitted.
For example, if *_vs* is specified, **(r, s)** and **v** can be omitted. Likewise,
if **recoverParam** is provided, **v** can be omitted (as it can be computed).
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
missing values can be computed).
Inspection
@ -75,16 +85,16 @@ Returns true if and only if *object* is a valid [Bytes](./).
#### *utils* . **isBytesLike** ( object ) **=>** *boolean*
Returns true if and only if *object* is a [Bytes](./) or an Array or TypedArray
where each value is a valid byte (i.e. between 0 and 255 inclusive).
Returns true if and only if *object* is a [Bytes](./) or [DataHexstring](./).
#### *utils* . **isHexString** ( object , [ length ] ) **=>** *boolean*
Returns true if and only if *object* is a valid hex string;
if *length* is specified the length (in bytes) is also verified.
Returns true if and only if *object* is a valid hex string.
If *length* is specified and *object* is not a valid [DataHexstring](./) of
*length* bytes, an InvalidArgument error is thrown.
@ -94,26 +104,24 @@ Converting between Arrays and Hexstrings
#### *utils* . **arrayify** ( hexstringOrArrayish [ , options ] ) **=>** *Uint8Array*
#### *utils* . **arrayify** ( datahexstringOrArrayish [ , options ] ) **=>** *Uint8Array*
Converts *hexstringOrArrayish* to a Uint8Array. If a [Hexstring](./)
is passed in, the length must be even.
Converts *datahexstringOrArrayish* to a Uint8Array.
#### *utils* . **hexlify** ( hexstringOrArrayish ) **=>** *string*
Converts *hexstringOrArrayish* to a [Hexstring](./). The result
will always be zero-padded to even length.
Converts *hexstringOrArrayish* to a [DataHexstring](./).
#### *utils* . **hexValue** ( aBigNumberish ) **=>** *string*
Converts *aBigNumberish* to a [Hexstring](./), with no unecessary leading
zeros. The result of this function can be of odd-length.
Converts *aBigNumberish* to a [Hexstring](./), with no *unnecessary* leading
zeros.
@ -123,29 +131,7 @@ zeros. The result of this function can be of odd-length.
```javascript
// Convert a hexstring to a Uint8Array
arrayify("0x1234")
// [ 18, 52 ]
// Convert an Array to a hexstring
hexlify([1, 2, 3, 4])
// 0x01020304
// Convert an Object to a hexstring
hexlify({ length: 2, "0": 1, "1": 2 })
// 0x0102
// Convert an Array to a hexstring
hexlify([ 1 ])
// 0x01
// Convert a number to a stripped hex value
hexValue(1)
// 0x1
// Convert an Array to a stripped hex value
hexValue([ 1, 2 ])
// 0x102
Skipping JavaScript Evaluation.
```
@ -157,22 +143,25 @@ Array Manipulation
#### *utils* . **concat** ( arrayOfBytesLike ) **=>** *Uint8Array*
Concatenates all the [BytesLike](./) in *arrayOfBytesLike*
into a single Uint8Array.
Concatenates all the [BytesLike](./) in *arrayOfBytesLike* into a single Uint8Array.
#### *utils* . **stripZeros** ( aBytesLike ) **=>** *Uint8Array*
Concatenates all the [BytesLike](./) in *arrayOfBytesLike*
Returns a Uint8Array with all leading `0` bytes of *aBtyesLike* removed.
#### *utils* . **zeroPad** ( aBytesLike , length ) **=>** *Uint8Array*
Concatenates all the [BytesLike](./) in *arrayOfBytesLike*
Retutns a Uint8Array of the data in *aBytesLike* with `0` bytes prepended to
*length* bytes long.
If *aBytesLike* is already longer than *length* bytes long, an InvalidArgument
error will be thrown.
@ -182,41 +171,43 @@ Hexstring Manipulation
#### *utils* . **hexConcat** ( arrayOfBytesLike ) **=>** *string*
#### *utils* . **hexConcat** ( arrayOfBytesLike ) **=>** *[DataHexstring](./)*
Concatenates all the [BytesLike](./) in *arrayOfBytesLike*
into a single [Hexstring](./)
Concatenates all the [BytesLike](./) in *arrayOfBytesLike* into a single [DataHexstring](./)
#### *utils* . **hexDataLength** ( aBytesLike ) **=>** *number*
Returns the length (in bytes) of *aBytesLike*.
This will **throw and error** if *aBytesLike* is a [Hexstring](./)
but is of odd-length.
#### *utils* . **hexDataSlice** ( aBytesLike , offset [ , endOffset ] ) **=>** *string*
#### *utils* . **hexDataLength** ( aBytesLike ) **=>** *[DataHexstring](./)*
Returns the length (in bytes) of *aBytesLike*.
#### *utils* . **hexStripZeros** ( aBytesLike ) **=>** *string*
#### *utils* . **hexDataSlice** ( aBytesLike , offset [ , endOffset ] ) **=>** *[DataHexstring](./)*
@TODO
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.
#### *utils* . **hexZeroPad** ( aBytesLike , length ) **=>** *string*
#### *utils* . **hexStripZeros** ( aBytesLike ) **=>** *[Hexstring](./)*
@TODO
Returns a [Hexstring](./) representation of *aBytesLike* with all
leading zeros removed.
#### *utils* . **hexZeroPad** ( aBytesLike , length ) **=>** *[DataHexstring](./)*
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.
@ -226,24 +217,22 @@ Signature Conversion
#### *utils* . **joinSignature** ( aSignatureLike ) **=>** *string*
#### *utils* . **joinSignature** ( aSignatureLike ) **=>** *[DataHexstring](./)*
Return the flat-format of a [SignatureLike](./), which is
65 bytes (130 nibbles) long, concatenating the **r**, **s** and **v**
of a Signature.
Return the flat-format of *aSignaturelike*, which is 65 bytes (130 nibbles)
long, concatenating the **r**, **s** and (normalized) **v** of a Signature.
#### *utils* . **splitSignature** ( aSignatureLikeOrBytesLike ) **=>** *Signature*
#### *utils* . **splitSignature** ( aSignatureLikeOrBytesLike ) **=>** *[Signature](./)*
Return the full expanded-format of a [SignatureLike](./) or
a flat-format [Hexstring](./). Any missing properties will be
computed.
Return the full expanded-format of *aSignaturelike* or a flat-format [DataHexstring](./).
Any missing properties will be computed.
-----
**Content Hash:** 1e52066c61f8794d858f02fb8164b146c9379968b0e0ab90efeb2fe16831599f
**Content Hash:** fce7a8c85402ef3d94ffe261157fa3e0644c5c5d0641d9de7820a9a798bcb6c7

72
docs/api/utils/bytes/index.html
View File

File diff suppressed because one or more lines are too long

23
docs/api/utils/constants/README.md
View File

@ -17,8 +17,7 @@ The **ethers.contants** Object contains commonly used values.
```javascript
//const { constants } = require("ethers");
// const { constants } = require("@ethersproject/constants");
Skipping JavaScript Evaluation.
```
@ -28,14 +27,14 @@ Bytes
#### *constants* . **AddressZero**
#### *constants* . **AddressZero** **=>** *[DataHexstring](../bytes)*
The Address Zero, which is 20 bytes (40 nibbles) of zero.
#### *constants* . **HashZero**
#### *constants* . **HashZero** **=>** *[DataHexstring](../bytes)*
The Hash Zero, which is 32 bytes (64 nibbles) of zero.
@ -47,7 +46,7 @@ Strings
#### *constants* . **EtherSymbol**
#### *constants* . **EtherSymbol** **=>** *string*
The Ether symbol, **&Xi;**.
@ -59,35 +58,35 @@ BigNumber
#### *constants* . **NegativeOne**
#### *constants* . **NegativeOne** **=>** *[BigNumber](../bignumber)*
The BigNumber value representing `"-1"`.
#### *constants* . **Zero**
#### *constants* . **Zero** **=>** *[BigNumber](../bignumber)*
The BigNumber value representing `"0"`.
#### *constants* . **One**
#### *constants* . **One** **=>** *[BigNumber](../bignumber)*
The BigNumber value representing `"1"`.
#### *constants* . **Two**
#### *constants* . **Two** **=>** *[BigNumber](../bignumber)*
The BigNumber value representing `"2"`.
#### *constants* . **WeiPerEther**
#### *constants* . **WeiPerEther** **=>** *[BigNumber](../bignumber)*
The BigNumber value representing `"1000000000000000000"`, which is the
number of Wei per Ether.
@ -95,7 +94,7 @@ number of Wei per Ether.
#### *constants* . **MaxUint256**
#### *constants* . **MaxUint256** **=>** *[BigNumber](../bignumber)*
The BigNumber value representing the maximum `uint256` value.
@ -104,4 +103,4 @@ The BigNumber value representing the maximum `uint256` value.
-----
**Content Hash:** a781a8990aec282632e70ebc003a711adf5bc7773243aed727fc37a0934097f7
**Content Hash:** 11a9a2e37a2a553b79931caf5374bcd894edf343a897c4253ddeaf4d2f8e1213

32
docs/api/utils/constants/index.html
View File

File diff suppressed because one or more lines are too long

26
docs/api/utils/display-logic/index.html
View File

File diff suppressed because one or more lines are too long

52
docs/api/utils/fixednumber/index.html
View File

File diff suppressed because one or more lines are too long

28
docs/api/utils/hashing/README.md
View File

@ -20,35 +20,35 @@ The [Cryptographic Hash Functions](https://en.wikipedia.org/wiki/Cryptographic_h
are a specific family of hash functions.
#### *utils* . **keccak256** ( aBytesLike ) **=>** *string*
#### *utils* . **keccak256** ( aBytesLike ) **=>** *[DataHexstring](../bytes)*
Returns the [KECCAK256](https://en.wikipedia.org/wiki/SHA-3) digest *aBytesLike*.
#### *utils* . **ripemd160** ( aBytesLike ) **=>** *string*
#### *utils* . **ripemd160** ( aBytesLike ) **=>** *[DataHexstring](../bytes)*
Returns the [RIPEMD-160](https://en.m.wikipedia.org/wiki/RIPEMD) digest of *aBytesLike*.
#### *utils* . **sha256** ( aBytesLike ) **=>** *string*
#### *utils* . **sha256** ( aBytesLike ) **=>** *[DataHexstring](../bytes)*
Returns the [SHA2-256](https://en.wikipedia.org/wiki/SHA-2) digest of *aBytesLike*.
#### *utils* . **sha512** ( aBytesLike ) **=>** *string*
#### *utils* . **sha512** ( aBytesLike ) **=>** *[DataHexstring](../bytes)*
Returns the [SHA2-512](https://en.wikipedia.org/wiki/SHA-2) digest of *aBytesLike*.
#### *utils* . **computeHmac** ( algorithm , key , data ) **=>** *string*
#### *utils* . **computeHmac** ( algorithm , key , data ) **=>** *[DataHexstring](../bytes)*
Returns the [HMAC](https://en.wikipedia.org/wiki/HMAC) of *data* with *key*
using the [Algorithm](./) *algorithm*.
@ -60,14 +60,14 @@ using the [Algorithm](./) *algorithm*.
#### *utils* . *SupportedAlgorithms* . **sha256**
#### *utils* . *SupportedAlgorithms* . **sha256** **=>** *string*
Use the [SHA2-256](https://en.wikipedia.org/wiki/SHA-2) hash algorithm.
#### *utils* . *SupportedAlgorithms* . **sha512**
#### *utils* . *SupportedAlgorithms* . **sha512** **=>** *string*
Use the [SHA2-512](https://en.wikipedia.org/wiki/SHA-2) hash algorithm.
@ -79,7 +79,7 @@ Common Hashing Helpers
#### *utils* . **hashMessage** ( message ) **=>** *string*
#### *utils* . **hashMessage** ( message ) **=>** *[DataHexstring](../bytes)*
Computes the Ethereum message digest of *message*. Ethereum messages are
converted to UTF-8 bytes and prefixed with `x19Ethereum Signed Message:`
@ -88,14 +88,14 @@ and the length of *message*.
#### *utils* . **id** ( text ) **=>** *string*
#### *utils* . **id** ( text ) **=>** *[DataHexstring](../bytes)*
The Ethereum Identity function computs the keccak256 hash of the *text* bytes.
#### *utils* . **namehash** ( name ) **=>** *string*
#### *utils* . **namehash** ( name ) **=>** *[DataHexstring](../bytes)*
Returns the [ENS Namehash](https://docs.ens.domains/contract-api-reference/name-processing#hashing-names) of *name*.
@ -111,7 +111,7 @@ When using the Solidity `abi.packEncoded(...)` function, a non-standard
the tightly packing algorithm.
#### *utils* . **solidityPack** ( arrayOfTypes , arrayOfValues ) **=>** *string*
#### *utils* . **solidityPack** ( arrayOfTypes , arrayOfValues ) **=>** *[DataHexstring](../bytes)*
Returns the non-standard encoded *arrayOfValues* packed according to
their respecive type in *arrayOfTypes*.
@ -119,7 +119,7 @@ their respecive type in *arrayOfTypes*.
#### *utils* . **solidityKeccak256** ( arrayOfTypes , arrayOfValues ) **=>** *string*
#### *utils* . **solidityKeccak256** ( arrayOfTypes , arrayOfValues ) **=>** *[DataHexstring](../bytes)*
Returns the KECCAK256 of the non-standard encoded *arrayOfValues* packed
according to their respective type in *arrayOfTypes*.
@ -127,7 +127,7 @@ according to their respective type in *arrayOfTypes*.
#### *utils* . **soliditySha256** ( arrayOfTypes , arrayOfValues ) **=>** *string*
#### *utils* . **soliditySha256** ( arrayOfTypes , arrayOfValues ) **=>** *[DataHexstring](../bytes)*
Returns the SHA2-256 of the non-standard encoded *arrayOfValues* packed
according to their respective type in *arrayOfTypes*.
@ -137,4 +137,4 @@ according to their respective type in *arrayOfTypes*.
-----
**Content Hash:** 65dd2158ef160da7be3291c8e7aac15df2de683869df9c31b8efdaa39551b3e4
**Content Hash:** 53b7b2b1fe243aebd3d5ff29c578538d0d068b0ff60b3426f7208cbf9f13d312

38
docs/api/utils/hashing/index.html
View File

File diff suppressed because one or more lines are too long

6
docs/api/utils/index.html
View File

File diff suppressed because one or more lines are too long

8
docs/api/utils/strings/README.md
View File

@ -27,7 +27,7 @@ null termination, we can store strings up to 31 bytes long in a
word.
#### **Note:**
#### Note
Strings that are 31 **bytes** long may contain fewer than 31 **characters**,
since UTF-8 requires multiple bytes to encode international characters.
@ -143,10 +143,10 @@ See NFKC for more an example.
#### **Note:**
#### Note
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
it should **not** be considered a method to acheive *any* level of security from
[homoglyph attacks](https://en.wikipedia.org/wiki/IDN_homograph_attack).
@ -154,4 +154,4 @@ it should not be considered a method to acheive *any* level of security from
-----
**Content Hash:** 74002cd3d9368872b5618f68967deac34a4d1aeafeeac6ddb5c1d06a450180c9
**Content Hash:** e38fe18f76e58587f7ed1c4558a5b3ec177eee1a5e71b4c88fa6d496154fdd8a

34
docs/api/utils/strings/index.html
View File

File diff suppressed because one or more lines are too long

3
docs/concepts/README.md
View File

@ -14,6 +14,7 @@ which developers can make use of or should be aware of.
* [Events](events)
* [Solidity Topics](events)
* [Gas](gas)
* [Gas Price](gas)
* [Gas Limit](gas)
@ -21,4 +22,4 @@ which developers can make use of or should be aware of.
-----
**Content Hash:** ad59f45600332d936821db1fa0d0eeabdab5b4f252e1e815de525b4d1b9a9a7b
**Content Hash:** 1846ad5571101be31cf9617167b5cc53338c83c0fc9389da19c8dd9d4153558b

9
docs/concepts/events/README.md
View File

@ -12,6 +12,13 @@ Events
Explain how topics and such work
Solidity Topics
---------------
How to compute the topic...
-----
**Content Hash:** 4b045e823bf9863272ddb1c5a8460bc461de2ad262503dc27829b64b57344d46
**Content Hash:** 1334c1751891f09ab9349dcc5b7e6705ef823cd7b15a18433c053c764c6b9042

8
docs/concepts/events/index.html
View File

File diff suppressed because one or more lines are too long

4
docs/concepts/gas/README.md
View File

@ -9,6 +9,8 @@ Gas
===
Explain attack vectors
Gas Price
---------
@ -26,4 +28,4 @@ Gas Limit
-----
**Content Hash:** 4cc3001196d861faac19ebc393e002ce9e6f24702b66bac62ef8f9185625b3dc
**Content Hash:** 2805374ab42eae31d185e96ae9308f0661dc826d460b33005a86f62fc2f17703

12
docs/concepts/gas/index.html
View File

File diff suppressed because one or more lines are too long

6
docs/concepts/index.html
View File

File diff suppressed because one or more lines are too long

8
docs/contributing/index.html
View File

File diff suppressed because one or more lines are too long

6
docs/cookbook/index.html
View File

File diff suppressed because one or more lines are too long

Some files were not shown because too many files have changed in this diff Show More