Fix JsonRpcProvider out-of-order super call (#822).

Ethers v5 beta

.circleci/config.yml

@@ -29,57 +29,56 @@ commands:
                 command: |
                   sudo apt-get purge chromium-browser
                   sudo apt-get update
-                  sudo apt-get install -y libappindicator1 fonts-liberation
+                  sudo apt-get install -y libappindicator1 fonts-liberation libgbm1
                   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
+          name: Update C build environment
           command: |
             sudo add-apt-repository ppa:ubuntu-toolchain-r/test
             sudo apt update
-            sudo apt install gcc-6
-            sudo apt install g++-6
+            sudo apt install gcc-6 g++-6 libusb-1.0-0-dev libudev-dev
             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: 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: 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: 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 >>

CHANGELOG.md

@@ -3,6 +3,212 @@ Changelog
 
 This change log is managed by `scripts/cmds/update-versions` but may be manually updated.
 
+During the v5-BETA, although attempts are made to minimize it, some of the APIs
+may change. It is generally recommended that you remove your `node_modules/`,
+`package-lock.json` (and similar files for yarn, etc.) and doing an `npm install`
+after upgrading to a newer version of the v5-BETA.
+
+ethers/v5.0.0-beta.185 (2020-05-04 22:54)
+-----------------------------------------
+
+  - More robust FallbackProvider on clean exits. ([8eeda23](https://github.com/ethers-io/ethers.js/commit/8eeda23e989fcb0126bd20b17c67f62466d19259))
+  - Safer test suite reporter timer. ([657a039](https://github.com/ethers-io/ethers.js/commit/657a0394f56b51a13c691477c2b0dcf74678fd7c))
+  - Added goerli to AlchemyProvider tests. ([ab7c781](https://github.com/ethers-io/ethers.js/commit/ab7c78118ab80990a3e3368749599a1cf6e9d4ae))
+  - Added more robust poll event to Provider. ([dc48bfb](https://github.com/ethers-io/ethers.js/commit/dc48bfb7adb9334848c93173ba2c634f22a9a72f))
+  - Added goerli to AlchemyProvider. ([86670eb](https://github.com/ethers-io/ethers.js/commit/86670eb80e96fc4ba4e3664c9389f8130bbfea73))
+  - Removed Cloudflare from test suite; it is down again. ([17dc022](https://github.com/ethers-io/ethers.js/commit/17dc022603afdfe4147638ab4b2704bcef09533f))
+  - Prevent forceOutput in test reporter from crashing. ([cafd344](https://github.com/ethers-io/ethers.js/commit/cafd34460b194d78092021f1d7e0307130340b68))
+  - Stall FallbackProvider backends from requests if not in-sync. ([fa6904f](https://github.com/ethers-io/ethers.js/commit/fa6904fef35e7ab888221f3a0613bfe7e6df3594))
+  - Allow providers to detect their network after instantiation. ([#814](https://github.com/ethers-io/ethers.js/issues/814); [99ae946](https://github.com/ethers-io/ethers.js/commit/99ae946476a317a9d89e5d8f57cf37f8680bfa2b))
+  - Better messaging on low-level network errors. ([#814](https://github.com/ethers-io/ethers.js/issues/814); [0e3a66c](https://github.com/ethers-io/ethers.js/commit/0e3a66c82959a08f3f4e4ffbca3ae3792ff2548f))
+  - Manage FallbackProvider stalling without unref. ([#815](https://github.com/ethers-io/ethers.js/issues/815); [7b1a7c7](https://github.com/ethers-io/ethers.js/commit/7b1a7c7f31a3631e12c2a341b562983360e670e9))
+  - Only error on duplicate signatures in Contract ABI. ([#499](https://github.com/ethers-io/ethers.js/issues/499); [098d7ef](https://github.com/ethers-io/ethers.js/commit/098d7efb21bd648c2660342297d2419904a10925))
+  - Added getWebSocketProvider static method to InfuraProvider. ([a6c1174](https://github.com/ethers-io/ethers.js/commit/a6c1174dffe6dca1a3a64d1d472cec6e12372117))
+  - Fix WebSocketProvider responses when message result is null. ([#813](https://github.com/ethers-io/ethers.js/issues/813); [472e5b0](https://github.com/ethers-io/ethers.js/commit/472e5b07eab180baa12185c8f00e5079ce4c671f))
+  - Allow modifiers on Human-Readable ABI for tuples and arrays. ([83fba3d](https://github.com/ethers-io/ethers.js/commit/83fba3de25b524cc48975b1952f4319d63874205))
+  - Added initial renew support to ENS CLI. ([54dfb75](https://github.com/ethers-io/ethers.js/commit/54dfb757c4c88e4bcada1890c4016fadfb25581a))
+  - Allow contract filters to include OR-ed values. ([#437](https://github.com/ethers-io/ethers.js/issues/437); [28800d7](https://github.com/ethers-io/ethers.js/commit/28800d7681f3bab08f6d30a22f0813e04feee18a))
+
+ethers/v5.0.0-beta.184 (2020-04-28 04:58)
+-----------------------------------------
+
+  - Removed old EIP-1193 experimental provider; it can now be supported by Web3Provider as EIP-1193 is now backwards compatible. ([84c68ac](https://github.com/ethers-io/ethers.js/commit/84c68ac5c17b10897ade966d6c8fac1f1f66a4af))
+  - Fixed getLogs filter deserialization. ([#805](https://github.com/ethers-io/ethers.js/issues/805); [393c0c7](https://github.com/ethers-io/ethers.js/commit/393c0c74a91175adca2e25026dcdb9e6445afd8f))
+  - Added EIP-1193 support to Web3Provider. ([56af441](https://github.com/ethers-io/ethers.js/commit/56af4413b1dd1787db68985e0b612b63d86fdf7c))
+  - Minor typing-detected fixes. ([d1f3a42](https://github.com/ethers-io/ethers.js/commit/d1f3a42c119d5588eab667ec7bb6e71042cfb656))
+  - Added initial support for recoverable coding erros. ([#800](https://github.com/ethers-io/ethers.js/issues/800); [bda6623](https://github.com/ethers-io/ethers.js/commit/bda66230916e58e25a522e8430ce4de25091eb6b))
+  - More draconian Typing. ([14e6811](https://github.com/ethers-io/ethers.js/commit/14e6811bf7d7c38a3b5714dededcc883c185d814))
+  - Omit HID libraries for hardware-wallets package on unsupported environments. ([#798](https://github.com/ethers-io/ethers.js/issues/798); [2e24920](https://github.com/ethers-io/ethers.js/commit/2e24920d028d42908d0764ad4ca0b56b55f852d1), [5aefb43](https://github.com/ethers-io/ethers.js/commit/5aefb4303d2fdda62e7e5ddb644919f613d6016a))
+  - Make default constructor non-payable. ([#684](https://github.com/ethers-io/ethers.js/issues/684); [017ea0d](https://github.com/ethers-io/ethers.js/commit/017ea0d6bd22833e9d399ae6b818443786f17884))
+
+ethers/v5.0.0-beta.183 (2020-04-23 23:28)
+-----------------------------------------
+
+  - Fixed inconsistent log format in WebSocketProvider. ([#795](https://github.com/ethers-io/ethers.js/issues/795); [8e7751f](https://github.com/ethers-io/ethers.js/commit/8e7751f7dfb41e58f81c7918cf36c152c3209ae2))
+  - Added WebSocketProvider support for ENS names in filters. ([6707754](https://github.com/ethers-io/ethers.js/commit/6707754580490c5a801d6205af0841794d20b3c9))
+  - Fixed provider filtering by ENS name. ([aeeb75f](https://github.com/ethers-io/ethers.js/commit/aeeb75f74c3be11b9b3b2925fd73349070542e54))
+  - Fixed ContractFactory.deploy ignoring overrides. ([#796](https://github.com/ethers-io/ethers.js/issues/796); [8bb2a0f](https://github.com/ethers-io/ethers.js/commit/8bb2a0fd08f6f128a80444e3fd90c29e4cd7edfb))
+  - Fix median calculation for large block number deltas across FallbackProvider backends. ([fca5ccb](https://github.com/ethers-io/ethers.js/commit/fca5ccbc2052569e700a96dbb1de1c9cef7c966f))
+  - Work-around for Cloudflare not offering eth_blockNumber. ([8cf4b3c](https://github.com/ethers-io/ethers.js/commit/8cf4b3cf4598f4f3643d5ebe9c366466d398cb83))
+  - Added string spell-checking to library and fixed discovered typos. ([71d03c6](https://github.com/ethers-io/ethers.js/commit/71d03c6e3cab1aacb3e4e74d3966fbaa7db2ee06))
+  - Fixed getUrl for node 8. ([560adea](https://github.com/ethers-io/ethers.js/commit/560adeabb06a2ab483bcad162f02ccef41ebc245))
+  - Dependency security updates. ([da3b0bf](https://github.com/ethers-io/ethers.js/commit/da3b0bf0786fe8a95c68485d130ca59c597ffe4d))
+  - Fixes for dist builds without injected XMLHttpRequest. ([#789](https://github.com/ethers-io/ethers.js/issues/789), [#506](https://github.com/ethers-io/ethers.js/issues/506); [9ae6b70](https://github.com/ethers-io/ethers.js/commit/9ae6b70efb9f3d3251820403597085cfa30ace05))
+
+ethers/v5.0.0-beta.182 (2020-04-16 21:53)
+-----------------------------------------
+
+  - Added support for Contract event parsing error recovery. ([cc72f76](https://github.com/ethers-io/ethers.js/commit/cc72f76695572d235d7f5a5ad4dc1838a5fe884a))
+  - Fix provider log filters with zero topics. ([#785](https://github.com/ethers-io/ethers.js/issues/785); [4ef0e4f](https://github.com/ethers-io/ethers.js/commit/4ef0e4f7653226bf8cca86e065ad614e7288af96))
+
+ethers/v5.0.0-beta.181 (2020-04-15 18:23)
+-----------------------------------------
+
+  - Temporarily remove CloudflareProvider tests; it is down and breaking the tests. ([797abb7](https://github.com/ethers-io/ethers.js/commit/797abb726711499d96bf1c12c61e3bb1a7b4925d))
+  - Better error reporting for Fragments. ([7dcefcb](https://github.com/ethers-io/ethers.js/commit/7dcefcbf71ef337103639bbe3f4ad2625565651a))
+  - Fixed Contract filter unsubscribing. ([2eb3823](https://github.com/ethers-io/ethers.js/commit/2eb3823de4ba111cc0c746a0715fe6dd3d1b16da), [39c78f3](https://github.com/ethers-io/ethers.js/commit/39c78f37ceff9b8ec08329903dcba7bd53bd8661))
+  - Fixed WebSocketProvider filter events. ([#784](https://github.com/ethers-io/ethers.js/issues/784); [69f7077](https://github.com/ethers-io/ethers.js/commit/69f707762ed5939c5f52bf6dce5c5513aaf6fa1d))
+  - Added bitwise operations to BigNumber. ([#781](https://github.com/ethers-io/ethers.js/issues/781); [7498c18](https://github.com/ethers-io/ethers.js/commit/7498c18235c7566b2f652cddba991f55e0943da8), [284771e](https://github.com/ethers-io/ethers.js/commit/284771ea39b6f4ee9cdf75ce5feea9e6aa9a65c5))
+
+ethers/v5.0.0-beta.180 (2020-04-03 22:10)
+-----------------------------------------
+
+  - Correctly return the Provider in NonceManager. ([6caf7c2](https://github.com/ethers-io/ethers.js/commit/6caf7c292cd5f03741cd6b30053c3325c4f30a81))
+  - Fail earlier when resolving an ENS name that is not a string. ([2882546](https://github.com/ethers-io/ethers.js/commit/28825463517f8821392464ec2283ee59c431d928))
+  - Fixed mutabilityState calculation for function fragments. ([#762](https://github.com/ethers-io/ethers.js/issues/762); [6526de0](https://github.com/ethers-io/ethers.js/commit/6526de016fda5403474dad61ee59acc62ee25ebc), [d7c8b35](https://github.com/ethers-io/ethers.js/commit/d7c8b355a049b36068b0525a357c6278639a8d58))
+  - Force Log properties to be non-optional. ([#415](https://github.com/ethers-io/ethers.js/issues/415); [da412f6](https://github.com/ethers-io/ethers.js/commit/da412f660723d1c411484e74970ce4eb166374c2), [8ad26f0](https://github.com/ethers-io/ethers.js/commit/8ad26f0ff42614a6c40e735cb6fffd36874da1a0))
+  - Fixed Signer call not forwarding blockTag. ([#768](https://github.com/ethers-io/ethers.js/issues/768); [053a2d7](https://github.com/ethers-io/ethers.js/commit/053a2d7fcdb4ca4c9bfd0bee0f42e0187d3db477))
+
+ethers/v5.0.0-beta.179 (2020-03-31 23:40)
+-----------------------------------------
+
+  - Fixed ENS CLI lookup for Website. ([0f144c6](https://github.com/ethers-io/ethers.js/commit/0f144c6cc03082026080782356b940af3389b34e))
+  - Fixed getEtherPrice for EtherscanProvider. ([#776](https://github.com/ethers-io/ethers.js/issues/776); [6c71b51](https://github.com/ethers-io/ethers.js/commit/6c71b515126d8ef3cea5a1aec814c4cab56cc1a5))
+  - Fixed ENS CLI tool set-websites and added set-name. ([70cffb6](https://github.com/ethers-io/ethers.js/commit/70cffb6a5166a79a54e02b03b6a7ec0085407e07))
+
+ethers/v5.0.0-beta.178 (2020-03-30 22:14)
+-----------------------------------------
+
+  - Fixed Event args keyword access. ([2692e78](https://github.com/ethers-io/ethers.js/commit/2692e783b40ce16207fa1a8e8513ebb5455fd2d0), [092ce9b](https://github.com/ethers-io/ethers.js/commit/092ce9bcc2abf92c40550c4a990a8e2c889cc250))
+  - Updating TypeScript library and fixing some audit issues. ([bd32ee0](https://github.com/ethers-io/ethers.js/commit/bd32ee0af5b25a435e5896773d8bfd482d3adcaf))
+
+ethers/v5.0.0-beta.177 (2020-03-21 12:46)
+-----------------------------------------
+
+  - Abstracted JSON-RPC parameter generation for others to use. ([030f65e](https://github.com/ethers-io/ethers.js/commit/030f65e66ce059d69d8d77973d5c3190745eaac2))
+  - Updated RLP package to use Logger instead of bare errors. ([390497f](https://github.com/ethers-io/ethers.js/commit/390497f38964a052837f6c0e7c96efe74c668517))
+  - Fixed log level filtering for Logger. ([#379](https://github.com/ethers-io/ethers.js/issues/379); [72c8992](https://github.com/ethers-io/ethers.js/commit/72c89922a4e1b77295414c8e0717a7373f2397b8))
+  - Throw errors when trying to RLP encode integers. ([9ea16e5](https://github.com/ethers-io/ethers.js/commit/9ea16e5172928962792ba4c0273e23db373409e0))
+  - Added delays to provider tests to prevent throttling causing failed tests. ([3e44aac](https://github.com/ethers-io/ethers.js/commit/3e44aac8f199ec09babb20c4af2ee668e0ab05a1))
+
+ethers/v5.0.0-beta.176 (2020-03-12 19:10)
+-----------------------------------------
+
+  - Checking in initial Eip1193Bridge (experimental). ([2c78f0b](https://github.com/ethers-io/ethers.js/commit/2c78f0bf265a0f7c9f4cfc1bc79ecd4629b59c49))
+  - Added initial WebSocketProvider. ([#141](https://github.com/ethers-io/ethers.js/issues/141); [117a5dd](https://github.com/ethers-io/ethers.js/commit/117a5dd7ffa783c4335c0b87621437447cd499d0))
+  - Renamed properties based on community recommendations; estimate to estimateGas and addressPromise to resovledAddress. ([fe3b3fa](https://github.com/ethers-io/ethers.js/commit/fe3b3fa1aded67827fec1131931d95d8153d8f32))
+  - Better error reporting and fixed look-ahead for data labels. ([e52312e](https://github.com/ethers-io/ethers.js/commit/e52312e783b8d0fdd7e9992716cbe2e179751b38))
+
+ethers/v5.0.0-beta.175 (2020-02-27 19:53)
+-----------------------------------------
+
+  - Fix address-less filter listening in Provider. ([#741](https://github.com/ethers-io/ethers.js/issues/741); [64dccb2](https://github.com/ethers-io/ethers.js/commit/64dccb275c68ebb40328350d4ab5be0f29b8a02e))
+  - Added sync version of wallet decryption. ([0ad94cd](https://github.com/ethers-io/ethers.js/commit/0ad94cdf8137259bedb38c0dc949b61570bcdac0), [6809c37](https://github.com/ethers-io/ethers.js/commit/6809c370c027aea148466c00d3ce09c6d0ee6ddc))
+
+ethers/v5.0.0-beta.175 (2020-02-27 19:38)
+-----------------------------------------
+
+  - Fix address-less filter listening in Provider. ([#741](https://github.com/ethers-io/ethers.js/issues/741); [64dccb2](https://github.com/ethers-io/ethers.js/commit/64dccb275c68ebb40328350d4ab5be0f29b8a02e))
+  - Added sync version of wallet decryption. ([0ad94cd](https://github.com/ethers-io/ethers.js/commit/0ad94cdf8137259bedb38c0dc949b61570bcdac0))
+
+ethers/v5.0.0-beta.174 (2020-02-25 14:57)
+-----------------------------------------
+
+  - Reduced default Provider quorum for testnets. ([1cfab31](https://github.com/ethers-io/ethers.js/commit/1cfab3173c3d0519beffc054efe73f70b7d28501))
+  - Added JSON-RPC debugging on error responses. ([ad27600](https://github.com/ethers-io/ethers.js/commit/ad27600c699827858e7343adff2d4fa622248e42))
+  - Fixed setLogLevel to affect global logging. ([ac51a88](https://github.com/ethers-io/ethers.js/commit/ac51a88c2913d7055e050c91d7d96bb42abf6656))
+  - Renamed interface getTopic to getEventTopic. ([f61f34b](https://github.com/ethers-io/ethers.js/commit/f61f34bfb295bafee3b7ee426efa696aaa9bbafe))
+  - Fix log parsing when no matching topic hash is found. ([#733](https://github.com/ethers-io/ethers.js/issues/733); [a5d2ec5](https://github.com/ethers-io/ethers.js/commit/a5d2ec534f75b21eebe69a789a3c43c33014a825), [4b8e198](https://github.com/ethers-io/ethers.js/commit/4b8e198bf209fcf0aea55018d8940355ea4345de), [89ac9f4](https://github.com/ethers-io/ethers.js/commit/89ac9f4f298ac340c4429e8ebdacd29962eba7f4))
+
+ethers/v5.0.0-beta.173 (2020-02-12 17:09)
+-----------------------------------------
+
+  - Added experimental EipWrappedProvider. ([944600d](https://github.com/ethers-io/ethers.js/commit/944600d779564c500ab98d3265286a0717642614))
+  - Updated signature for JsonRpcProvider.send to match EIP-1193. ([b962b59](https://github.com/ethers-io/ethers.js/commit/b962b59ab72e67bc4566a361964e42cf1b791025))
+  - Added binary literal support to ASM grammar. ([375bd15](https://github.com/ethers-io/ethers.js/commit/375bd15594a3179432e8452d819d91ea72b4bdd8))
+  - Added explicit pop placeholders to ASM dialect. ([a6b696d](https://github.com/ethers-io/ethers.js/commit/a6b696d8bd03c4027b52fe23745f066d158f1420))
+  - Added position independent code option for asm. ([89615c5](https://github.com/ethers-io/ethers.js/commit/89615c59d385a58fa79b6bbd8eae53c30e45fe96))
+  - Added ASM semantic checking and the Pop placeholder. ([a33bf0e](https://github.com/ethers-io/ethers.js/commit/a33bf0e37f4f969cc03b85ebf0dbadcf3e9b068a))
+  - Better type safety for defineReadOnly. ([e7adc84](https://github.com/ethers-io/ethers.js/commit/e7adc84a972968f39a983efb6f21b6ceaacd6cc5))
+  - Fixed CLI sandbox quiting after prompt entry. ([ff9bc2a](https://github.com/ethers-io/ethers.js/commit/ff9bc2a282e617125bbca76702dec85149661390))
+
+ethers/v5.0.0-beta.172 (2020-02-04 00:59)
+-----------------------------------------
+
+  - Synced GitHub issue cache. ([13dbf1f](https://github.com/ethers-io/ethers.js/commit/13dbf1f965eab344d2a304f7612d19ea96391261))
+  - Better typing for Timers. ([5622f70](https://github.com/ethers-io/ethers.js/commit/5622f703d962993442623ef1450a595825c4efa8))
+  - Safer transaction serialization, matching signature.v with chainId. ([#708](https://github.com/ethers-io/ethers.js/issues/708); [edb7c5d](https://github.com/ethers-io/ethers.js/commit/edb7c5da91ce271688561364d867998b0f0675e3))
+  - Fixed Opcode typo and added check to prevent future typos. ([15bb840](https://github.com/ethers-io/ethers.js/commit/15bb8409077f96b22e8bd60c426cddd015454e6b))
+  - Renamed AST nodes for teh assembler. ([f02c7db](https://github.com/ethers-io/ethers.js/commit/f02c7db4109d1785b4528757aa50f24948e896ae))
+  - Added timeout to waitForTransaction. ([#477](https://github.com/ethers-io/ethers.js/issues/477); [bacc440](https://github.com/ethers-io/ethers.js/commit/bacc4403979fa423890e269e7a5c7d11c6891a9f))
+  - Added CLI for asm package. ([aafa42a](https://github.com/ethers-io/ethers.js/commit/aafa42a32b2a5c7481a409ad048dfc06112c6599))
+  - Prevent Signer.checkTransaction from creating conflicting from properties. ([1decb13](https://github.com/ethers-io/ethers.js/commit/1decb1379902b60a15925b9b1de39633393db825))
+  - Include asm in generated TypeScript dependencies. ([ba29618](https://github.com/ethers-io/ethers.js/commit/ba296188960fb345dfdab12f2bb3ed3dc5eab51a))
+  - Clean up some asm checks and dead code. ([fa317eb](https://github.com/ethers-io/ethers.js/commit/fa317ebc032f8a5f9fb2dd10e23496252ae744e1))
+  - More contained Opcode API. ([da8153c](https://github.com/ethers-io/ethers.js/commit/da8153c87753b79e5e4cd34d484b8e0e717426d9))
+  - Added initial codedrop for the asm package. ([0296594](https://github.com/ethers-io/ethers.js/commit/0296594aba8d1e90e9ef7a18d2324f6cac815953))
+
+ethers/v5.0.0-beta.171 (2020-02-01 05:05)
+-----------------------------------------
+
+  - Added CLI for asm package. ([aafa42a](https://github.com/ethers-io/ethers.js/commit/aafa42a32b2a5c7481a409ad048dfc06112c6599))
+  - Added more flatworm documentation. ([1c85fe9](https://github.com/ethers-io/ethers.js/commit/1c85fe95b2b536828e83087676becba85c9a90bb))
+  - Prevent Signer.checkTransaction from creating conflicting from properties. ([1decb13](https://github.com/ethers-io/ethers.js/commit/1decb1379902b60a15925b9b1de39633393db825))
+  - Include asm in generated TypeScript dependencies. ([ba29618](https://github.com/ethers-io/ethers.js/commit/ba296188960fb345dfdab12f2bb3ed3dc5eab51a))
+  - Clean up some asm checks and dead code. ([fa317eb](https://github.com/ethers-io/ethers.js/commit/fa317ebc032f8a5f9fb2dd10e23496252ae744e1))
+  - More contained Opcode API. ([da8153c](https://github.com/ethers-io/ethers.js/commit/da8153c87753b79e5e4cd34d484b8e0e717426d9))
+  - Added initial codedrop for the asm package. ([0296594](https://github.com/ethers-io/ethers.js/commit/0296594aba8d1e90e9ef7a18d2324f6cac815953))
+
+ethers/v5.0.0-beta.171 (2020-01-29 21:41)
+-----------------------------------------
+
+  - Better solc support in CLI; it will search the local pacakge for an existing solc version. ([7428776](https://github.com/ethers-io/ethers.js/commit/7428776f75222d5c07282bc29c3dd8ed99f5d2cc))
+  - Update ENS registry address and lower default quorum for testnets. ([edb49da](https://github.com/ethers-io/ethers.js/commit/edb49da15518f25b3d60813ebb84f54171e308f3))
+  - Exposed isBytes and isBytesLike in ethers.utils. ([99329b0](https://github.com/ethers-io/ethers.js/commit/99329b013ce7f3af301d40c41f7eb35bff288910))
+
+ethers/v5.0.0-beta.170 (2020-01-21 20:37)
+-----------------------------------------
+
+  - Better, easier and more provider testing. ([e0d1d38](https://github.com/ethers-io/ethers.js/commit/e0d1d3866d2559f39627254873a0a1d4c0fcaf3d))
+  - Fixed out-of-bounds difficulty in getBlock, which can affect PoA networks. ([#711](https://github.com/ethers-io/ethers.js/issues/711); [251882c](https://github.com/ethers-io/ethers.js/commit/251882ced4379931ec82ba28a4db10bc7dbf3580))
+
+ethers/v5.0.0-beta.169 (2020-01-20 19:42)
+-----------------------------------------
+
+  - Fixed imports after refactor. ([adf5622](https://github.com/ethers-io/ethers.js/commit/adf56229c6cc83003d319ea9a004677e2555d478))
+  - Refactor some enum names and add UTF-8 error support to the umbrella package. ([931da2f](https://github.com/ethers-io/ethers.js/commit/931da2f77446fc9266cf07f0d7d78d4376625005))
+  - Allow arbitrary apiKey for UrlJsonRpcProvider. ([5878b54](https://github.com/ethers-io/ethers.js/commit/5878b54d6eded1329a6dc3b4023f876a87f72b6e))
+  - Added more general error handling (e.g. error, ignore, replace) for calling toUtf8String. ([a055edb](https://github.com/ethers-io/ethers.js/commit/a055edb5855b96fdf179403458c1694b96fd906c))
+
+ethers/v5.0.0-beta.168 (2020-01-18 21:46)
+-----------------------------------------
+
+  - Much more resiliant FallbackProvider which can ignore properties that are only approximate and supports per-provider priorities. ([#635](https://github.com/ethers-io/ethers.js/issues/635), [#588](https://github.com/ethers-io/ethers.js/issues/588); [f4bcf24](https://github.com/ethers-io/ethers.js/commit/f4bcf24a257a17ec9beb98f3d0b3682de543534c))
+  - Fixed some typing for receipts and logs. ([#497](https://github.com/ethers-io/ethers.js/issues/497); [ea102ef](https://github.com/ethers-io/ethers.js/commit/ea102ef7c4fa5df7b9389fbc8a2947bbbd4c471e))
+  - Abstracting mnemonic phrases. ([#685](https://github.com/ethers-io/ethers.js/issues/685); [92a383f](https://github.com/ethers-io/ethers.js/commit/92a383ff0dad4587e44953efca3c6ab795a1b1bd))
+  - Sync GitHub issues. ([75e1a37](https://github.com/ethers-io/ethers.js/commit/75e1a37bb5935d5d538ffcfce5b0073e1334d457))
+  - Fixed 304 status for fetchJson. ([c66d81e](https://github.com/ethers-io/ethers.js/commit/c66d81e96f7c9b0808f181085ffe1c92f6219d46))
+
+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)
 -----------------------------------------
 

admin/build.js

@@ -49,13 +49,6 @@ function run(progname, args, ignoreErrorStream) {
 }
 
 function setupConfig(outDir, moduleType, targetType) {
-    function update(value) {
-        let comps = value.split("/");
-        if (comps.length >= 3 && comps[0] === "." && comps[1].match(/^lib(\.esm)?$/)) {
-            return outDir + comps.slice(2).join("/");
-        }
-        return value;
-    }
 
     // Configure the tsconfit.package.json...
     const path = resolve(__dirname, "../tsconfig.package.json");
@@ -64,22 +57,24 @@ function setupConfig(outDir, moduleType, targetType) {
     content.compilerOptions.target = targetType;
     saveJson(path, content);
 
+    // Configure the browser field for every pacakge, copying the
+    // browser.umd filed for UMD and browser.esm for ESM
     dirnames.forEach((dirname) => {
         let info = loadPackage(dirname);
 
         if (info._ethers_nobuild) { return; }
 
-        [ "browser", "_browser" ].forEach((key) => {
-            if (info[key]) {
-                if (typeof(info[key]) === "string") {
-                    info[key] = update(info[key]);
-                } else {
-                    for (let k in info[key]) {
-                        info[key][k] = update(info[key][k]);
-                    }
-                }
+        if (targetType === "es2015") {
+            if (info["browser.esm"]) {
+                info.browser = info["browser.esm"];
             }
-        });
+        } else if (targetType === "es5") {
+            if (info["browser.umd"]) {
+                info.browser = info["browser.umd"];
+            }
+        } else {
+            throw new Error("unsupported target");
+        }
         savePackage(dirname, info);
 
         let path = resolve(__dirname, "../packages", dirname, "tsconfig.json");

admin/changelog.js

@@ -105,9 +105,41 @@ async function generate() {
     return formatted.join("\n") + "\n";
 }
 
+function getChanges() {
+    const changes = [ ];
+
+    let lastLine = null;
+    fs.readFileSync(ChangelogPath).toString().split("\n").forEach((line) => {
+        line = line.trim();
+        if (line === "") { return; }
+
+        if (line.substring(0, 5) === "-----") {
+            changes.push({ title: lastLine, lines: [ ] });
+        } else if (line.substring(0, 1) === "-" && changes.length) {
+            changes[changes.length - 1].lines.push(line);
+        }
+        lastLine = line;
+    });
+
+    return changes;
+}
+
+function latestChange() {
+    const recent = getChanges()[0];
+
+    const match = recent.title.match(/ethers\/([^\(]*)\(([^\)]*)\)/);
+
+    return {
+        title: recent.title,
+        version: match[1].trim(),
+        data: match[2].trim(),
+        content: recent.lines.join("\n")
+    };
+}
+
 module.exports = {
     generate: generate,
+    latestChange: latestChange,
     ChangelogPath: ChangelogPath,
 }
 
-

admin/cmds/publish.js

@@ -2,13 +2,16 @@
 
 const config = require("../config");
 
+const { latestChange } = require("../changelog");
 const { getOrdered, loadPackage } = require("../depgraph");
+const { createRelease } = require("../github");
 const { getPackageVersion, publish } = require("../npm");
 const { log } = require("../log");
 
 const USER_AGENT = "ethers-dist@0.0.0";
 const TAG = "next";
 
+
 let dirnames = getOrdered();
 
 // Only publish specific packages
@@ -32,6 +35,8 @@ if (process.argv.length > 2) {
 (async function() {
     let token = null;
 
+    let includeEthers = false;
+
     // @TODO: Fail if there are any untracked files or unchecked in files
 
     // Load the token from the encrypted store
@@ -68,6 +73,7 @@ if (process.argv.length > 2) {
 
         if (dirname === "ethers") {
             options.tag = "next";
+            includeEthers = true;
         } else {
             options.tag = "latest";
         }
@@ -89,4 +95,20 @@ if (process.argv.length > 2) {
         log("  <green:Done.>");
     }
 
+    // Publish the GitHub release (currently beta)
+    const beta = true;
+    if (includeEthers) {
+
+        // The password above already succeeded
+        const username = await config.get("github-user");
+        const password = await config.get("github-release");
+
+        // Get the latest change from the changelog
+        const change = latestChange();
+
+        // Publish the release
+        const link = await createRelease(username, password, change.version, change.title, change.content, beta);
+        log(`<bold:Published Release:> ${ link }`);
+    }
+
 })();

admin/cmds/set-option.js

@@ -4,39 +4,32 @@ const { loadPackage, savePackage } = require("../local");
 const arg = process.argv[2];
 
 (async function() {
-    switch(arg) {
-        case "esm":
-            setupBuild(true);
-            break;
+    process.argv.slice(2).forEach((arg) => {
+        console.log("Setting Option:", arg);
+        switch(arg) {
+            case "esm":
+                setupBuild(true);
+                break;
 
-        case "cjs":
-            setupBuild(false);
-            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;
+            // This will remove the browser field entirely, so make sure
+            // to set esm of cjs first as they will restore the browser
+            // field
+            case "browser-lang-all": {
+                const info = loadPackage("wordlists");
                 delete info.browser;
                 savePackage("wordlists", info);
+                break;
             }
-            break;
-        }
 
-        default:
-            console.log("unknown option");
-            return 1;
-    }
+            default:
+                console.log("Unknown option:", arg);
+                return 1;
+      }
+    });
     return 0;
 
 })().then((result) => {

admin/cmds/spell-check.js

@@ -0,0 +1,210 @@
+"use strict";
+
+const { resolve } = require("path");
+const fs = require("fs");
+
+const Words = fs.readFileSync("/usr/share/dict/words").toString().split("\n").reduce((accum, word) => {
+    accum[word.toLowerCase()] = true;
+    return accum;
+}, { });
+
+`
+// Words missing from the dictionary
+accessing addresses aligned autofill called cancelled censored
+compiled computed configured consumed creating decoded decoding
+decrypt decrypted decrypting deployed deploying deprecated detected
+discontinued earliest email enabled encoded encoding encrypt
+encrypted encrypting entries euro exceeded existing expected
+expired failed fetches formatted formatting funding generated
+has ignoring implemented implementer imported including instantiate
+keyword labelled larger lookup matches mined modified modifies multi
+named nested neutered numeric offline optimizer owned packed
+padded parsed parsing passed placeholder processing reached
+recommended recovered redacted remaining replaced required
+serializes shared signed signing stored supported tagging targetted
+transactions uninstall unsubscribe using verifies website
+
+// Overly Specific Words
+BIP BIP39 BIP44 crypto eip hashes hmac icap
+keccak namehash ripemd RLP scrypt secp sha
+
+blockhash
+
+bitcoin ethereum finney gwei kwei mwei satoshi szabo wei weth
+
+crowdsale hexlify hd hdnode underpriced
+
+boolean int struct tuple uint
+nonpayable
+jumpdest mstore shr shl xor
+
+// Classes
+ABIEncoder testcase numberish Wordlist
+
+// Common Code Strings
+abi addr api app arg arrayify asm basex bigint bn byte bytecode
+callback calldata checksum ciphertext cli codepoint config
+contenthash ctr ctrl debug dd dklen eexist encseed eof ethaddr
+ethseed ethers eval exec filename func gz hid http https hw iv
+info init ipc json kdf kdfparams labelhash lang lib mm multihash nfc
+nfkc nfd nfkd nodehash oob opcode pbkdf pc plugin pragma pre prf
+repl rpc sighash topichash solc stdin stdout subclasses subnode
+timeout todo txt ufixed utc utf util url uuid vm vs websocket
+wikipedia wx xe yyyy zlib
+
+// AbiV2
+abiv
+
+// Query parameters
+apikey asc endblock startblock
+
+Cloudflare Etherscan INFURA IPFS MetaMask Nodesmith Trezor ledgerhq
+axic bitcoinjs browserify easyseed ethereumjs
+goerli homestead kotti kovan mainnet morden mordor rinkeby ropsten testnet
+
+// Demo words
+args foo eth foo foobar ll localhost passwd ricmoo tx xxx yna
+
+// nameprep tags
+ALCat BiDi LCat nameprep
+
+// Lanauge Codes (and short binary data)
+cn cz en es fr it ja tw zh zh_cn zh_tw
+OYAa IJBEJqXZJ
+
+`.split("\n").filter((l) => (l.substring(0, 2) != "/\/")).join("\n").split(/\s+/g,).forEach((word) => {
+    word = word.trim();
+    if (word === "") { return; }
+    Words[word.toLowerCase()] = true;
+});
+
+const ts = require("typescript");
+
+function getStrings(source) {
+    const sourceFile = ts.createSourceFile("filename.ts", source);
+
+    const result = [ ];
+
+    function add(value, pos) {
+        const lineNo = sourceFile.getLineAndCharacterOfPosition(pos).line + 1;
+        result.push({ value, lineNo });
+    }
+
+    let lastClass = null, lastEnum = null;
+    function visit(node, depth) {
+        switch (node.kind) {
+            //case ts.SyntaxKind.TemplateExpression:
+            //    if (node.head) { visit(node.head); }
+            //    console.dir(node, { depth: null });
+            //    break;
+            case ts.SyntaxKind.TemplateHead:
+            case ts.SyntaxKind.TemplateMiddle:
+            case ts.SyntaxKind.TemplateTail:
+            case ts.SyntaxKind.StringLiteral:
+            case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+                add(node.text, node.pos);
+                break;
+        }
+
+        ts.forEachChild(node, (node) => { return visit(node, depth + 1); });
+    }
+
+    visit(sourceFile, 0);
+
+    return result;
+}
+
+const Include = new RegExp("packages/.*/src.ts/.*\.ts$");
+const Exclude = new RegExp("/node_modules/|src.ts/.*browser.*");
+
+function getAllStrings(path) {
+    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), values: getStrings(source) } ]
+        }
+
+        return [ ];
+    }
+
+    return readdir(Root);
+}
+
+function checkWord(word) {
+    word = word.toLowerCase();
+
+    // A word
+    if (Words[word]) { return true; }
+
+    // Simple Plural
+    if (word.match(/.*s$/) && Words[word.substring(0, word.length - 1)]) { return true; }
+
+    // Hex string
+    if (word.match(/^(0x)?[0-9a-f]*$/i)) { return true; }
+}
+
+function starts(text, prefix) {
+    return (text.substring(0, prefix.length) === prefix);
+}
+
+(async function() {
+    let count = 0;
+    getAllStrings(resolve(__dirname, "../../packages")).forEach((file) => {
+        if (starts(file.filename, "/testcases/src.ts/generation-scripts")) { return; }
+        if (starts(file.filename, "/asm/src.ts/opcodes.ts")) { return; }
+
+        file.values.forEach((entry) => {
+            function problem(word) {
+                count++;
+                console.log({
+                    filename: file.filename,
+                    word: JSON.stringify(word),
+                    sentence: JSON.stringify(entry.value.substring(0, 80)),
+                    line: entry.lineNo
+                });
+            }
+
+            const value = entry.value.trim();
+
+            // Emptry space
+            if (value === "") { return; }
+
+            // Prolly a require
+            if (value.match(/^@ethersproject\/[a-z0-9-]+$/)) { return; }
+            if (value.substring(0, 2) === "./") { return; }
+
+            // Prolly encoded binary data
+            if (value.indexOf(" ") === -1 && value.length > 20) { return; }
+
+            if (checkWord(value)) { return; }
+
+            value.replace(/([a-z+])([A-Z])/g, (all, first, secondLetter) => {
+                return first + " " + secondLetter;
+            }).replace(/((?:0x)?[A-Za-z]+)/gi, (all, word) => {
+                if (checkWord(word)) { return; }
+                problem(word);
+                return "";
+            });;
+        });
+    });
+    if (count) {
+        console.log(`Found ${ count } typos.`);
+        process.exit(1)
+    }
+    process.exit(0)
+})();
+

admin/config.js

@@ -57,6 +57,11 @@ Config.prototype.load = async function() {
     }
 };
 
+Config.prototype.keys = async function() {
+    await this.load();
+    return Object.keys(this.values);
+}
+
 Config.prototype.save = function() {
     this.values._junk = Buffer.from(randomBytes(16 + parseInt(Math.random() * 48))).toString("base64")
 
@@ -102,6 +107,9 @@ module.exports = {
     set: function(key, value) {
         config.set(key, value);
     },
+    keys: function() {
+        return config.keys();
+    },
     lock: function() {
         config.lock();
     }

admin/github.js

@@ -107,7 +107,7 @@ async function fetchGitHub(user, password, url, cacheOnly) {
 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)
+    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++) {
@@ -128,7 +128,35 @@ function syncIssues(user, password) {
     return _getIssues(user, password);
 }
 
+async function createRelease(user, password, tagName, title, body, prerelease, commit) {
+    const payload = {
+        tag_name: tagName,
+        target_commitish: (commit || "master"),
+        name: title,
+        body: body,
+        //draft: true,
+        draft: false,
+        prerelease: !!prerelease
+    };
+
+    const headers = {
+        "User-Agent": "ethers-io",
+    };
+
+    const result = await fetchJson({
+        url: "https://api.github.com/repos/ethers-io/ethers.js/releases",
+        user: user,
+        password: password,
+        headers: headers
+    }, JSON.stringify(payload));
+
+
+    return result.html_url;
+}
+
 module.exports = {
     getIssues,
     syncIssues,
+    createRelease,
 }
+

docs.wrm/.gitignore

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

docs.wrm/README.md

@@ -11,6 +11,13 @@ Building
 --------
 
 ```
-/home/ricmoo/ethers.js> npm run build-docs 
+/home/ricmoo/ethers.js> npm run build-docs
 ```
 
+
+License
+-------
+
+All documentation for ethers.js and Flatworm is released under the
+[Creative Commons Attribution 4.0 International License](https://choosealicense.com/licenses/cc-by-4.0/)
+license.

docs.wrm/api/contract.wrm

@@ -1,8 +0,0 @@
-_title: Contracts
-
-_null: Contract @<contract>
-_section: Contracts
-
-Explain what contracts are...
-
-_subsection: Buckets

docs.wrm/api/contract/contract-factory.wrm

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

docs.wrm/api/contract/contract.wrm

@@ -0,0 +1,169 @@
+_section: Contract @<Contract> @SRC<contracts:class.Contract>
+
+Explain contract here...
+
+_subsection: Creating Instances @<contract--creating>
+
+_property: new ethers.Contract(address, abi, signerOrProvider) @src<contracts:constructor.Contract>
+
+_property: contract.attach(addressOrName) => [[Contract]]  @<contract-attach> @SRC<contracts:Contract.attach>
+Returns a new instance of the **Contract** attached to a new
+address. This is useful if there are multiple similar or identical
+copies of a Contract on the network and you wish to interact with
+each of them.
+
+_property: contract.connect(providerOrSigner) => [[Contract]]  @<contract-connect> @SRC<contracts:Contract.connect>
+Returns a new instance of the Contract, but connected to
+//providerOrSigner//.
+
+By passing in a [[Provider]], this will return a downgraded
+**Contract** which only has read-only access (i.e. constant calls).
+
+By passing in a [[Signer]]. the will return a **Contract** which
+will act on behalf of that signer.
+
+
+_subsection: Properties  @<contrct--properties>
+
+_property: contract.address => string<[[address]]>
+This is the address (or ENS name) the contract was constructed with.
+
+_property: contract.resolvedAddress => string<[[address]]>
+This is a promise that will resolve to the address the **Contract**
+object is attached to. If an [[address]] was provided to the constructor,
+it will be equal to this; if an ENS name was provided, this will be the
+resolved address.
+
+_property: contract.deployTransaction => [[providers-TransactionResponse]]
+If the **Contract** object is the result of a ContractFactory deployment,
+this is the transaction which was used to deploy the contract.
+
+_property: contract.interface => [[Interface]]
+This is the ABI as an [[Interface]].
+
+_property: contract.provider => [[Provider]]
+If a provider was provided to the constructor, this is that provider. If
+a signer was provided that had a [[Provider]], this is that provider.
+
+_property: contract.signer => [[Signer]]
+If a signer was provided to the constructor, this is that signer.
+
+
+_subsection: Methods
+
+_property: contract.deployed() => Promise<[[Contract]]>  @<contract-deployed> @SRC<contracts>
+
+_property: Contract.isIndexed(value) => boolean  @<contract-isIndexed> @SRC<contracts>
+
+
+_subsection: Events
+
+_property: contract.queryFilter(event [ , fromBlockOrBlockHash [ , toBlock ]) => Promise<Array<Event>> @<contract-queryFilter> @SRC<contracts>
+Return Events that match the //event//.
+
+_property: contract.listenerCount([ event ]) => number  @<contract-listenerCount> @SRC<contracts:Contract.listenerCount>
+Return the number of listeners that are subscribed to //event//. If
+no event is provided, returns the total count of all events.
+
+_property: contract.listeners(event) => Array<Listener>  @<contract-listeners> @SRC<contracts:Contract.listeners>
+Return a list of listeners that are subscribed to //event//.
+
+_property: contract.off(event, listener) => this  @<contract-off> @SRC<contracts>
+Unsubscribe //listener// to //event//.
+
+_property: contract.on(event, listener) => this  @<contract-on> @SRC<contracts>
+Subscribe to //event// calling //listener// when the event occurs.
+
+_property: contract.once(event, listener) => this  @<contract-once> @SRC<contracts>
+Subscribe once to //event// calling //listener// when the event
+occurs.
+
+_property: contract.removeAllListeners([ event ]) => this  @<contract-removeAllListeners> @SRC<contracts:Contract.removeAllListeners>
+Unsubscribe all listeners for //event//. If no event is provided,
+all events are unsubscribed.
+
+
+_subsection: Meta-Class  @<contract--metaclass>
+
+A Meta-Class is a Class which has any of its properties determined
+at run-time. The **Contract** object uses a Contract's ABI to
+determine what methods are available, so the following sections
+describe the generic ways to interact with the properties added
+at run-time during the **Contract** constructor.
+
+
+_heading: Read-Only Methods (constant)  @<contract--readonly>
+
+A constant method is read-only and evaluates a small amount of EVM
+code against the current blockchain state and can be computed by
+asking a single node, which can return a result. It is therefore
+free and does not require any ether, but **cannot make changes** to
+the blockchain state..
+
+_property: contract.METHOD_NAME(...args [ overrides ]) => Promise<any>  @<contract-functionsCall>
+The type of the result depends on the ABI.
+
+For values that have a simple meaning in JavaScript, the types are fairly
+straight forward; strings and booleans are returned as JavaScript strings
+and booleans.
+
+For numbers, if the **type** is in the JavaSsript safe range (i.e. less
+than 53 bits, such as an ``int24`` or ``uint48``) a normal JavaScript
+number is used. Otherwise a [[BigNumber]] is returned.
+
+For bytes (both fixed length and dynamic), a [[DataHexString]] is returned.
+
+
+_heading: Write Methods (non-constant) @<contract--write>
+
+A non-constant method requires a transaction to be signed and requires
+payment in the form of a fee to be paid to a miner. This transaction
+will be verified by every node on the entire network as well by the
+miner who will compute the new state of the blockchain after executing
+it against the current state.
+
+It cannot return a result. If a result is required, it should be logged
+using a Solidity event (or EVM log), which can then be queried from the
+transaction receipt.
+
+_property: contract.METHOD_NAME(...args [ , overrides ]) => Promise<[[providers-TransactionResponse]]>  @<contract-functionsSend>
+Returns a [[providers-TransactionResponse]] for the transaction after
+it is sent to the network. This requires the **Contract** has a
+signer.
+
+
+_heading: Write Methods Analysis @<contract--check>
+
+There are secveral options to analyze properties and results of a
+write method without actually executing it.
+
+_property: contract.estimateGas.METHOD_NAME(...args [ , overrides ]) => Promise<[[BigNumber]]>  @<contract-estimateGas>
+Returns the estimate units of gas that would be required to
+execute the //METHOD_NAME// with //args// and //overrides//.
+
+_property: contract.populateTransaction.METHOD_NAME(...args [ , overrides ]) => Promise<[UnsignedTx](UnsignedTransaction)>  @<contract-populateTransaction>
+Returns an [[UnsignedTransaction]] which represents the transaction
+that would need to be signed and submitted to the network to execute
+//METHOD_NAME// with //args// and //overrides//.
+
+_property: contract.staticCall.METHOD_NAME(...args [ , overrides ]) => Promise<any>  @<contract-staticCall>
+Rather than executing the state-change of a transaction, it is possible
+to ask a node to //pretend// that a call is not state-changing and
+return the result.
+
+This does not actually chagne any state, but is free. This in some cases
+can be used to determine if a transaction will fail or succeed.
+
+This otherwise functions the same as a [Read-Only Method](contract--readonly).
+
+_heading: Event Filters @<contract-filters>
+An event filter is made up of topics, which are values logged in a
+[[link-wiki-bloomfilter]], allowing efficient searching for entries
+which match a filter.
+
+_property: contract.filters.EVENT_NAME(...args) => Filter
+Return a filter for //EVENT_NAME//, optionally filtering by additional
+constraints.
+
+Only ``indexed`` event parameters may be filtered. If a parameter is
+null (or not provided) then any value in that field matches.

docs.wrm/api/contract/example.wrm

@@ -0,0 +1,186 @@
+_section: Example: ERC-20 Contract
+
+_subsection: Connecting to a Contract
+
+_code: A simple ERC-20 contract @lang<javascript>
+
+// A Human-Readable ABI; any supported ABI format could be used
+const abi = [
+    // Read-Only Functions
+    "function balanceOf(address owner) view returns (uint256)",
+    "function decimals() view returns (uint8)",
+    "function symbol() view returns (string)",
+
+    // Authenticated Functions
+    "function transfer(address to, uint amount) returns (boolean)",
+
+    // Events
+    "event Transfer(address indexed from, address indexed to, uint amount)"
+];
+
+// This can be an address or an ENS name
+const address = "dai.tokens.ethers.eth";
+
+// An example Provider
+const provider = ethers.getDefaultProvider();
+
+// An example Signer
+const signer = ethers.Wallet.createRandom().connect(provider);
+
+// Read-Only; By connecting to a Provider, allows:
+// - Any constant function
+// - Querying Filters
+// - Populating Unsigned Transactions for non-constant methods
+// - Estimating Gas for non-constant (as an anonymous sender)
+// - Static Calling non-constant methods (as anonymous sender)
+const erc20 = new ethers.Contract(address, abi, provider);
+
+// Read-Write; By connecting to a Signer, allows:
+// - Everything from Read-Only (except as Signer, not anonymous)
+// - Sending transactions for non-constant functions
+const erc20_rw = new ethers.Contract(address, abi, signer)
+
+
+_heading: ERC20Contract @INHERIT<[[Contract]]>
+
+_property: new ethers.Contract(address, abi, providerOrSigner)
+See the above code example for creating an Instance which will
+(in addition to the Contact methods and properties) automatically
+add the additional properties defined in //abi// to a **Contract**
+connected to //address// using the //providerOrSigner//.
+
+
+_subsection: Properties @NOTE<(inheritted from [[Contract]])>
+
+_property: erc20.address => string<[[address]]>
+This is the address (or ENS name) the contract was constructed with.
+
+_property: erc20.resolvedAddress => string<[[address]]>
+This is a promise that will resolve to the address the **Contract**
+object is attached to. If an [[address]] was provided to the constructor,
+it will be equal to this; if an ENS name was provided, this will be the
+resolved address.
+
+_property: erc20.deployTransaction => [[providers-TransactionResponse]]
+If the **Contract** object is the result of a ContractFactory deployment,
+this is the transaction which was used to deploy the contract.
+
+_property: erc20.interface => [[Interface]]
+This is the ABI as an [[Interface]].
+
+_property: erc20.provider => [[Provider]]
+If a provider was provided to the constructor, this is that provider. If
+a signer was provided that had a [[Provider]], this is that provider.
+
+_property: erc20.signer => [[Signer]]
+If a signer was provided to the constructor, this is that signer.
+
+
+_subsection: Methods @NOTE<(inheritted from [[Contract]])>
+
+_property: erc20.attach(addressOrName) => [[Contract]]
+Returns a new instance of the **Contract** attached to a new
+address. This is useful if there are multiple similar or identical
+copies of a Contract on the network and you wish to interact with
+each of them.
+
+_property: erc20.connect(providerOrSigner) => [[Contract]]
+Returns a new instance of the Contract, but connected to
+//providerOrSigner//.
+
+By passing in a [[Provider]], this will return a downgraded
+**Contract** which only has read-only access (i.e. constant calls).
+
+By passing in a [[Signer]]. the will return a **Contract** which
+will act on behalf of that signer.
+
+_property: erc20.deployed() => Promise<Contract>
+
+_property: Contract.isIndexed(value) => boolean
+
+
+_subsection: Events @NOTE<(inheritted from [[Contract]])> @<erc20-events>
+
+_property: erc20.queryFilter(event [ , fromBlockOrBlockHash [ , toBlock ]) => Promise<Array<Event>> @<erc20-queryfilter>
+Return Events that match the //event//.
+
+_property: erc20.listenerCount([ event ]) => number
+Return the number of listeners that are subscribed to //event//. If
+no event is provided, returns the total count of all events.
+
+_property: erc20.listeners(event) => Array<Listener>
+Return a list of listeners that are subscribed to //event//.
+
+_property: erc20.off(event, listener) => this
+Unsubscribe //listener// to //event//.
+
+_property: erc20.on(event, listener) => this
+Subscribe to //event// calling //listener// when the event occurs.
+
+_property: erc20.once(event, listener) => this
+Subscribe once to //event// calling //listener// when the event
+occurs.
+
+_property: erc20.removeAllListeners([ event ]) => this
+Unsubscribe all listeners for //event//. If no event is provided,
+all events are unsubscribed.
+
+
+_subsection: Meta-Class Methods @NOTE<(added at Runtime)>
+
+Since the Contract is a Meta-Class, the methods available here depend
+on the ABI which was passed into the **Contract**.
+
+_property: erc20.decimals([ overrides ]) => Promise<number>
+Returns the number of decimal places used by this ERC-20 token. This can be
+used with [parseUnits](utils-parseUnits) when taking input from the user or
+[formatUnits](utils-formatunits] when displaying the token amounts in the UI.
+
+_property: erc20.getBalance(owner [, overrides ]) => Promise<[[BigNumber]]>
+Returns the balance of //owner// for this ERC-20 token.
+
+_property: erc20.symbol([ overrides ]) => Promise<string>
+Returns the symbol of the token.
+
+_property: erc20_rw.transfer(target, amount [, overrides ]) => Promise<[[providers-TransactionResponse]]>
+Transfers //amount// tokens to //target// from the current signer.
+The return value (a boolean) is inaccessible during a write operation
+using a transaction. Other techniques (such as events) are required
+if this value is required. On-chain contracts calling the ``transfer``
+function have access to this result, which is why it is possible.
+
+_property: erc20.callStatic.transfer(target, amount [, overrides ]) => Promise<boolean>
+Performs a dry-run of transferring //amount// tokens to //target// from
+the current signer, without actually signing or sending a transaction.
+
+This can be used to preflight check that a transaction will be successful.
+
+_property: erc20.estimateGas.transfer(target, amount [, overrides ]) => Promise<[[BigNumber]]>
+Returns an estimate for how many units of gas would be required
+to transfer //amount// tokens to //target//.
+
+_property: erc20.populateTransaction.transfer(target, amount [, overrides ]) => Promise<[UnsignedTx](UnsignedTransaction)>
+Returns an [[UnsignedTransaction]] which could be signed and submitted
+to the network to transaction //amount// tokens to //target//.
+
+
+_note: Note on Estimating and Static Calling
+
+When you perform a static call, the current state is taken into account as
+best as Ethereum can determine. There are many cases where this can provide
+false positives and false negatives. The eventually consistent model of the
+blockchain also means there are certain consistency modes that cannot be
+known until an actual transaction is attempted.
+
+
+_subsection: Meta-Class Filters @NOTE<(added at Runtime)>
+
+Since the Contract is a Meta-Class, the methods available here depend
+on the ABI which was passed into the **Contract**.
+
+_property: erc20.filters.Transafer([ fromAddress [ , toAddress ] ]) => Filter
+Returns a new Filter which can be used to [query](erc20-queryfilter) or
+to [subscribe/unsubscribe to events](erc20-events).
+
+If //fromAddress// is null or not provided, then any from address matches.
+If //toAddress// is null or not provided, then any to address matches.

docs.wrm/api/contract/index.wrm

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

docs.wrm/api/experimental.wrm

@@ -0,0 +1,65 @@
+_section: Experimental
+
+The **Experimental** package is used for features that are not ready
+to be included in the base library. The API should not be considered
+stable and does not follow [[link-semver]] versioning, so applications
+requiring it should specify the //exact version// needed.
+
+_subsection: BrainWallet @<experimental-brainwallet> @INHERIT<[[Wallet]]>
+
+Ethers removed support for BrainWallets in v4, since they are unsafe and
+many can be easily guessed, allowing attackers to steal the funds. This
+class is offered to ensure older systems which used brain wallets can
+still recover their funds and assets.
+
+_property: BrainWallet.generate(username, password [ , progressCallback ]) => [[experimental-brainwallet]]
+Generates a brain wallet, with a slightly improved experience, in which
+the generated wallet has a mnemonic.
+
+_property: BrainWallet.generateLegacy(username, password [ , progressCallback ]) => [[experimental-brainwallet]]
+Generate a brain wallet which is compatibile with the ethers v3 and earlier.
+
+
+_subsection: EIP1193Bridge @<experimental-eip1193bridge> @INHERIT<[[link-npm-events]]>
+
+The **EIP1193Bridge** allows a normal Ethers [[Signer]] and [[Provider]] to be
+exposed in as a standard [EIP-1193 Provider](link-eip-1193), which may be useful
+when interacting with other libraries.
+
+
+_subsection: NonceManager @<experimental-noncemanager> @INHERIT<[[Signer]]>
+
+The **NonceManager** is designed to manage the nonce for a Signer,
+automatically increasing it as it sends transactions.
+
+Currently the NonceManager does not handle re-broadcast. If you attempt
+to send a lot of transactions to the network on a node that does not
+control that account, the transaction pool may drop your transactions.
+
+In the future, it'd be nice if the **NonceManager** remembered transactions
+and watched for them on the network, rebroadcasting transactions that
+appear to have been dropped.
+
+Another future feature will be some sort of failure mode. For example, often
+a transaction is dependent on another transaction being mined first.
+
+_property: new NonceManager(signer)
+Create a new NonceManager.
+
+_property: nonceManager.signer => [[Signer]]
+The signer whose nonce is being managed.
+
+_property: nonceManager.provider => [[Provider]]
+The provider associated with the signer.
+
+_property: nonceManager.setTransactionCount(count) => void
+Set the current transaction count (nonce) for the signer.
+
+This may be useful it interacting with the signer outside of using
+this class.
+
+_property: nonceManager.increaseTransactionCount( [ count = 1 ]) => void
+Bump the current transaction count (nonce) by //count//.
+
+This may be useful it interacting with the signer outside of using
+this class.

docs.wrm/api/index.wrm

@@ -1,11 +1,12 @@
-_title: Application Programming Interface
+_section: Application Programming Interface @NAV<API>
 
-_section: Application Programming Interface (API)
-
-Here...
+An Application Programming Interface (API) is the formal
+specification of the library.
 
 _toc:
     contract
     signer
     providers
     utils
+    other
+    experimental

docs.wrm/api/other/assembly/api.wrm

@@ -0,0 +1,86 @@
+_section: Utilities @<asm-utilities>
+
+_subsection: Assembler
+
+The assembler utilities allow parsing and assembling an
+[Ethers ASM Dialect](asm-dialect) source file.
+
+_property: asm.parse(code) => [[asm-node]] @<asm-parse> @SRC<asm/assembler>
+Parse an ethers-format assembly file and return the [[asm-ast]].
+
+_property: asm.assemble(node) => string<[[DataHexString]]> @SRC<asm/assembler:function.assemble>
+Performs assembly of the [[asm-ast]] //node// and return the
+resulting bytecode representation.
+
+
+_subsection: Disassembler
+
+The **Disassembler** utilities make it easy to convert bytecode
+into an object which can easily be examined for program structure.
+
+_property: asm.disassemble(bytecode) => [[asm-bytecode]] @SRC<asm/assembler>
+Returns an array of Operations given //bytecode//.
+
+_property: asm.formatBytecode(operations) => string @SRC<asm/assembler>
+Create a formatted output of an array of [[asm-operation]].
+
+_heading: Bytecode @<asm-bytecode> @INHERIT<Array\<[[asm-operation]]\>>
+
+Each arary index represents an operation, collapsing multi-byte operations
+(i.e. ``PUSH``) into a single operation.
+
+_property: bytecode.getOperation(offset) => [[asm-operation]]
+Get the operation at a given //offset// into the bytecode. This ensures that
+the byte at //offset// is an operation and not data contained within a ``PUSH``,
+in which case null it returned.
+
+_heading: Operation @<asm-operation>
+
+An **Operation** is a single command from a disassembled bytecode
+stream.
+
+_property: operation.opcode => [[asm-opcode]]
+The opcode for this Operation.
+
+_property: operation.offset => number
+The offset into the bytecode for this Operation.
+
+_property: operation.pushValue => string<[[DataHexString]]>
+If the opcode is a ``PUSH``, this is the value of that push
+
+
+_subsection: Opcode @<asm-opcode> @SRC<asm/opcodes:class.Opcode>
+
+_property: asm.Opcode.from(valueOrMnemonic) => [[asm-opcode]]
+Create a new instnace of an Opcode for a given numeric value
+(e.g. 0x60 is PUSH1) or mnemonic string (e.g. "PUSH1").
+
+_heading: Properties
+
+_property: opcode.value => number
+The value (bytecode as a number) of this opcode.
+
+_property: opcode.mnemonic => string
+The mnemonic string of this opcode.
+
+_property: opcode.delta => number
+The number of items this opcode will consume from the stack.
+
+_property: opcode.alpha => number
+The number of items this opcode will push onto the stack.
+
+_property: opcode.doc => string
+A short description of what this opcode does.
+
+_property: opcode.isMemory() => "read" | "write" | "full"
+Returns true if the opcode accesses memory.
+
+_property: opcode.isStatic() => boolean
+Returns true if the opcode cannot change state.
+
+_property: opcode.isJump() => boolean
+Returns true if the opcode is a jumper operation.
+
+_property: opcode.isPush() => number
+Returns 0 if the opcode is not a ``PUSH*``, or the number
+of bytes this opcode will push if it is.

docs.wrm/api/other/assembly/ast.wrm

@@ -0,0 +1,150 @@
+_section: Abstract Syntax Tree @<asm-ast>
+
+Parsing a file using the [Ethers ASM Dialect](asm-dialect) will
+generate an Abstract Syntax Tree. The root node will always
+be a [[asm-scopenode]] whose name is ``_``.
+
+To parse a file into an Abstract Syntax tree, use the [parse](asm-parse)
+function.
+
+
+_subsection: Types
+
+_heading: Location @<asm-location>
+
+_property: offset => number
+The offset into the source code to the start of this node.
+
+_property: length => number
+The length of characters in the source code to the end of this node.
+
+_property: source => string
+The source code of this node.
+
+
+_subsection: Nodes
+
+@TODO: Place a diagram here showing the hierarchy
+
+_heading: Node @<asm-node> @SRC<asm:class.Node>
+
+_property: node.tag => string
+A unique tag for this node for the lifetime of the process.
+
+_property: node.location => [[asm-location]]
+The source code and location within the source code that this
+node represents.
+
+
+_heading: ValueNode @<asm-valuenode> @INHERIT<[[asm-node]]> @SRC<asm:class.ValueNode>
+
+A **ValueNode** is a node which may manipulate the stack.
+
+
+_heading: LiteralNode @<asm-literalnode> @INHERIT<[[asm-valuenode]]> @SRC<asm:class.LiteralNode>
+
+_property: literalNode.value => string
+The literal value of this node, which may be a [[DataHexString]] or
+string of a decimal number.
+
+_property: literalNode.verbatim => boolean
+This is true in a [[asm-datanode]] context, since in that case the
+value should be taken verbatim and no ``PUSH`` operation shoud be
+added, otherwise false.
+
+
+_heading: PopNode @<asm-popnode> @INHERIT<[[asm-valuenode]]> @SRC<asm:class.PopNode>
+
+A **PopNode** is used to store a place-holder for an implicit pop from the
+stack. It represents the code for an implicit place-holder (i.e. ``$$``) or an
+explicit place-holder (e.g. ``$1``), which indicates the expect stack position
+to consume.
+
+_property: literalNode.index => number
+
+The index this **PopNode** is representing. For an implicit place-holder
+this is ``0``.
+
+
+_heading: LinkNode @<asm-linknode> @INHERIT<[[asm-valuenode]]> @SRC<asm:class.LinkNode>
+
+A **LinkNode** represents a link to another [[asm-node]]'s data,
+for example ``$foo`` or ``#bar``.
+
+_property: linkNode.label => string
+Te name of the target node.
+
+_property: linkNode.type => "offset" | "length"
+Whether this node is for an offset or a length value of the
+target node.
+
+
+_heading: OpcodeNode @<asm-opcodenode> @INHERIT<[[asm-valuenode]]> @SRC<asm:class.OpcodeNode>
+
+_property: opcodeNode.opcode => [[asm-opcode]]
+The opcode for this Node.
+
+_property: opcodeNode.operands => Array<[[asm-valuenode]]>
+A list of all operands passed into this Node.
+
+
+_heading: EvaluationNode @<asm-evaluationnode> @INHERIT<[[asm-valuenode]]> @SRC<asm:class.EvaluationNode>
+
+An **EvaluationNode** is used to execute code and insert the results
+but does not generate
+any output assembly, using the ``{{! code here }}`` syntax.
+
+_property: literalNode.verbatim => boolean
+This is true in a [[asm-datanode]] context, since in that case the
+value should be taken verbatim and no ``PUSH`` operation shoud be
+added, otherwise false.
+
+_property: evaluationNode.script => string
+The code to evaluate and produce the result to use as a literal.
+
+
+_heading: ExecutionNode @<asm-executionnode> @INHERIT<[[asm-node]]> @SRC<asm:class.ExecutionNode>
+
+An **ExecutionNode** is used to execute code but does not generate
+any output assembly, using the ``{{! code here }}`` syntax.
+
+_property: evaluationNode.script => string
+The code to execute. Any result is ignored.
+
+
+_heading: LabelledNode @<asm-labellednode> @INHERIT<[[asm-node]]> @SRC<asm:class.LabelledNode>
+
+A **LabelledNode** is used for any Node that has a name, and can therefore
+be targetted by a [[asm-linknode]].
+
+_property: labelledNode.name => string
+The name of this node.
+
+
+_heading: LabelNode @<asm-labelnode> @INHERIT<[[asm-labellednode]]> @SRC<asm:class.LabelNode>
+
+A **LabelNode** is used as a place to ``JUMP`` to by referencing it
+name, using ``@myLabel:``. A ``JUMPDEST`` is automatically inserted
+at the bytecode offset.
+
+
+_heading: DataNode @<asm-datanode> @INHERIT<[[asm-labellednode]]> @SRC<asm:class.DataNode>
+
+A **DataNode** allows for data to be inserted directly into the output
+assembly, using ``@myData[ ... ]``. The data is padded if needed to ensure
+values that would otherwise be regarded as a ``PUSH`` value does not impact
+anything past the data.
+
+_property: dataNode.data => Array<[[asm-valuenode]]>
+The child nodes, which each represent a verbatim piece of data in insert.
+
+_heading: ScopeNode @<asm-scopenode> @INHERIT<[[asm-labellednode]]> @SRC<asm:class.ScopeNode>
+
+
+A **ScopeNode** allows a new frame of reference that all [[asm-linknode]]'s
+will use when resolving offset locations, using ``@myScope{ ... }``.
+
+_property: scopeNode.statements => Array<[[asm-node]]>
+The list of child nodes for this scope.
+
+

docs.wrm/api/other/assembly/dialect.wrm

@@ -0,0 +1,115 @@
+_section: Ethers ASM Dialect @<asm-dialect>
+
+This provides a quick, high-level overcview of the **Ethers ASM Dialect**
+for EVM, which is defined by the [Ethers ASM Dialect Grammar](link-ethers-asm-grammar)
+
+Once a program is compiled by a higher level langauge into ASM (assembly),
+or hand-coded directly in ASM, it needs to be assembled into bytecode.
+
+The assembly process performs a very small set of operations and is
+intentionally simple and closely related to the underlying EVM bytecode.
+
+Operations include embedding programs within programs (for example the
+deployment bootstrap has the runtime embedded in it) and computing the
+necessary offsets for jump operations.
+
+The [Command-Line Assembler](cli-asm) can be used to assemble an
+//Ethers ASM Dialect// file or to disassemble bytecode into its
+human-readable (ish) opcodes and literals.
+
+
+_subsection: Opcodes @<asm-dialect-opcode>
+
+An **Opcode** may be provided in either a //functional// or
+//instructional// syntax. For Opcodes that require parameters,
+the //functional// syntax is recommended and the //instructional//
+syntax will raise a warning.
+
+@TODO: Examples
+
+
+_subsection: Labels @<asm-dialect-label>
+
+A **Label** is a position in the program which can be jumped to. A
+``JUMPDEST`` is automatically added to this point in the assembled
+output.
+
+@TODO: Exmaples
+
+
+_subsection: Literals @<asm-dialect-literal>
+
+A **Literal** puts data on the stack when executed using a ``PUSH``
+operation.
+
+A **Literal** can be provided using a [[DataHexString]] or a decimal
+byte value.
+
+@TODO: exmples
+
+
+_subsection: Comments @<asm-dialect-comment>
+
+To enter a comment in the **Ethers ASM Dialect**, any text following
+a semi-colon (i.e. ``;``) is ignored by the assembler.
+
+
+_subsection: Scopes @<asm-dialect-scope>
+
+A common case in Ethereum is to have one program embedded in another.
+
+The most common use of this is embedding a Contract **runtime bytecode**
+within a **deployment bytecode**, which can be used as **init code**.
+
+When deploying a program to Ethereum, an **init transaction** is used. An
+//init transaction// has a null ``to`` address and contains bytecode in
+the ``data``. This ``data`` bytecode is a program, that when executed
+returns some other bytecode as a result, this restul is the bytecode
+to be installed.
+
+Therefore it is important that embedded code uses jumps relative to itself,
+not the entire program it is embedded in, which also means that a jump
+can **only** target its own scope, no parent or child scopes. This is
+enforced by the assembler.
+
+A scope may access the offset of any child [[asm-dialect-datasegment]] or
+child [[asm-dialect-scope]] (with respect to itself) and may access the length
+of any [[asm-dialect-datasegment]] or [[asm-dialect-scope]] anywhere in the program.
+
+Every program in the **Ethers ASM Dialect** has a top-leve scope named ``_``.
+
+
+_subsection: Data Segment @<asm-dialect-datasegment>
+
+A **Data Segment** allows arbitrary data to be embedded into a program,
+which can be useful for lookup tables or deploy-time constants.
+
+An emtpty **Data Segment** can also be used when a labelled location is
+required, but without the ``JUMPDEST`` which a [[asm-dialect-label]] adds.
+
+@TODO: Example
+
+
+_subsection: Links @<asm-dialect-links>
+
+A **Link** allows access to a [[asm-dialect-scope]], [[asm-dialect-datasegment]] or [[asm-dialect-label]].
+
+To access the byte offset of a labelled item, use ``$foobar``.
+
+For a [[asm-dialect-label]], the target must be directly reachable within this scope. For
+a [[asm-dialect-datasegment]] or a [[asm-dialect-scope]], it can be inside the same scope or any
+child scope.
+
+For a [[asm-dialect-datasegment]] or a [[asm-dialect-label]], there is an additional type of
+**Link**, which provides the length of the data or bytecode respectively. A
+**Length Link** is accessed by ``#foobar`` and is pushed on the stack as a
+literal.
+
+
+_subsection: Stack Placeholders @<asm-dialect-placeholder>
+
+@TODO: exampl
+
+
+_subsection: Evaluation and Excution @<asm-dialect-scripting>
+

docs.wrm/api/other/assembly/index.wrm

@@ -0,0 +1,6 @@
+_section: Assembly
+
+_toc:
+    dialect
+    api
+    ast

docs.wrm/api/other/hardware/index.wrm

@@ -0,0 +1,20 @@
+_section: Hardware Wallets
+
+
+_subsection: LedgerSigner @<hw-ledger> @INHERIT<[[Signer]]> @SRC<hardware-wallets:class.LedgerSigner>
+
+The [Ledger Hardware Wallets](link-ledger) are a fairly
+popular brand.
+
+
+_code: Importing in ES6 or TypeScript @lang<script>
+
+import { LedgerSigner } from "@ethersproject/hardware-wallets";
+
+
+_heading: API
+
+_property: new LedgerSigner([provider [, type [ , path ] ] ]) => [[hw-ledger]]
+Connects to a Ledger Hardware Wallet. The //type// if left unspecified is
+determined by the environment; in node the default is "hid" and in the browser
+"u2f" is the default. The default Ethereum path is used if //path// is left unspecified.

docs.wrm/api/other/index.wrm

@@ -0,0 +1,9 @@
+_section: Other Libraries
+
+Now that ethers is more modular, it is possible to have additional
+ancillary packages, which are not part of the core but optionally
+add functionality only needed in certain situations.
+
+_toc:
+    assembly
+    hardware

docs.wrm/api/providers/api-providers.wrm

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

docs.wrm/api/providers/example-account.js

@@ -1,29 +0,0 @@
-// <hide>
-
-const { ethers } = require("./packages/ethers");
-const provider = ethers.getDefaultProvider()
-
-function _inspect(result) {
-    if (ethers.BigNumber.isBigNumber(result)) {
-        return `{ BigNumber: ${ JSON.stringify(result.toString()) } }`;
-    }
-    return JSON.stringify(result);
-}
-
-// </hide>
-
-// Get the balance for an account...
-provider.getBalance("ricmoo.firefly.eth");
-//!
-
-// Get the code for a contract...
-provider.getCode("registrar.firefly.eth");
-//!
-
-// Get the storage value at position 0...
-provider.getStorageAt("registrar.firefly.eth", 0)
-//!
-
-// Get transaction count of an account...
-provider.getTransactionCount("ricmoo.firefly.eth");
-//!

docs.wrm/api/providers/example-ens.js

@@ -1,15 +0,0 @@
-// <hide>
-
-const { ethers } = require("./packages/ethers");
-const provider = ethers.getDefaultProvider()
-
-// </hide>
-
-// Reverse lookup of an ENS by address...
-provider.lookupAddress("0x6fC21092DA55B392b045eD78F4732bff3C580e2c");
-//!
-
-// Lookup an address of an ENS name...
-provider.resolveName("ricmoo.firefly.eth");
-//!
-

docs.wrm/api/providers/index.wrm

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

docs.wrm/api/providers/jsonrpc-provider.wrm

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

docs.wrm/api/providers/other.wrm

@@ -1,37 +1,110 @@
-_title: Other Providers
-
 _section: Other Providers
 
 Others...
 
-_subsection: FallbackProvider @<provider-fallback> @INHERIT<[[provider]]>
+_subsection: FallbackProvider  @<FallbackProvider> @INHERIT<[[Provider]]> @SRC<providers/fallback-provider:class.FallbackProvider>
 
-Explain...
+The **FallbackProvider** is the most advanced [[Provider]] available in
+ethers.
 
-_heading: Properties
+It uses a quorum and connects to multiple [Providers](Provider) as backends,
+each configured with a //priority// and a //weight// .
 
-_property: provider.providers => Array<[[provider]]>
-The list of Providers this is connected to.
+When a request is made, the request is dispatched to multiple backends, randomly
+choosen (higher prioirty backends are always selected first) and the results from
+each are compared against the others. Only once the quorum has been reached will that
+result be accepted and returned to the caller.
+
+By default the quorum requires 50% (rounded up) of the backends to agree. The //weight//
+can be used to give a backend Provider more influence.
+
+_property: new ethers.providers.FallbackProvider(providers [ , quorum ])
+Creates a new instance of a FallbackProvider connected to //providers//. If
+quorum is not specified, half of the total sum of the provider weights is
+used.
+
+The //providers// can be either an array of [[Provider]] or [[FallbackProviderConfig]].
+If a [[Provider]] is provided, the defaults are a priority of 1 and a weight of 1.
+
+_property: provider.providerConfigs => Array<[[FallbackProviderConfig]]>
+The list of Provider Configurations that describe the backends.
 
 _property: provider.quorum => number
 The quorum the backend responses must agree upon before a result will be
 resolved. By default this is //half the sum of the weights//.
 
-_property: provider.weights => Array<number>
-The weight each of the Providers adds to a results acceptance.
+
+_heading: FallbackProviderConfig  @<FallbackProviderConfig>
+
+_property: fallbackProviderConfig.provider => [[Provider]]
+The provider for this configuration.
+
+_property: fallbackProviderConfig.priority => number
+The priority used for the provider. Higher priorities are favoured over lower
+priorities. If multiple providers share the same prioirty, they are choosen
+at random.
+
+_property: fallbackProviderConfig.stallTimeout => number
+The timeout (in ms) after which another [[Provider]] will be attempted. This
+does not affect the current Provider; if it returns a result it is counted
+as part of the quorum.
+
+Lower values will result in more network traffic, but may reduce the response
+time of requests.
+
+_property: fallbackProviderConfig.weight => number
+The weight a response from this provider provides. This can be used if a given
+[[Provider]] is more trusted, for example.
 
 
-_subsection: IpcProvider @<provider-ipc> @INHERIT<[[jsonrpc-provider]]>
+_subsection: IpcProvider  @<IpcProvider> @INHERIT<[[JsonRpcProvider]]> @SRC<providers:class.IpcProvider>
 
-Explain...
+The **IpcProvider** allows the JSON-RPC API to be used over a local
+filename on the file system, exposed by Geth, Parity and other nodes.
 
-_subsection: UrlJsonRpcProvider @<urljsonrpc-provider> @INHERIT<[[jsonrpc-provider]]>
+This is only available in //node.js// (as it requires file system access,
+and may have additional complications due to file permissions. See any
+related notes on the documentation for the actual node implementation websites.
 
-Tra la la
+_property: ipcProvider.path => string
+The path this [[Provider]] is connected to.
 
-_subsection: Web3Provider @<web3provider> @INHERIT<[[jsonrpc-provider]]>
 
-Tra la la
+_subsection: UrlJsonRpcProvider @<UrlJsonRpcProvider> @INHERIT<[[JsonRpcProvider]]> @SRC<providers:class.UrlJsonRpcProvider>
+
+This class is intended to be sub-classed and not used directly. It
+simplifies creating a [[Provider]] where a normal [[JsonRpcProvider]]
+would suffice, with a little extra effort needed to generate the JSON-RPC
+URL.
+
+_property: new ethers.providers.UrlJsonRpcProvider([ network [ , apiKey ] ])
+Sub-classes do not need to override this. Instead they should override the
+static method ``getUrl`` and optionally ``getApiKey``.
+
+_property: urlJsonRpcProvider.apiKey => any
+The value of the apiKey that was returned from ``InheritedClass.getApiKey``.
+
+_property: InheritingClass.getApiKey(apiKey) => any
+This function should examine the //apiKey// to ensure it is valid and
+return a (possible modified) value to use in ``getUrl``.
+
+_property: InheritingClass.getUrl(network, apiKey) => string
+The URL to use for the JsonRpcProvider instance.
 
 
 
+_subsection: Web3Provider @<Web3Provider> @INHERIT<[[JsonRpcProvider]]>
+
+The Web3Provider is meant to ease moving from a [web3.js based](link-web3)
+application to ethers by wraping an existing Web3-compatible (such as a
+[Web3HttpProvider](link-web3-http)[Web3IpcProvider](link-web3-ipc) or
+[Web3WsProvider](link-web3-ws)) and exposing it as an ethers.js [[Provider]]
+which can then be used with the rest of the library.
+
+_property: new ethers.providers.Web3Provider(web3Provider [, network ])
+Create a new **Web3Provider**, which wraps an [EIP-1193 Provider]() or
+Web3Provider-compatible Provider.
+
+_property: web3Provider.provider => Web3CompatibleProvider
+The provider used to create this instance.
+

docs.wrm/api/providers/provider.wrm

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

docs.wrm/api/providers/types.wrm

@@ -1,75 +1,301 @@
-_title: Types
-
 _section: Types
 
-_heading: BlockTag @<provider-blocktag>
+_subsection: BlockTag @<providers-BlockTag>
 A **BlockTag** specifies a specific location in the Blockchain.
 
 - **``"latest"``** -- The most recently mined block
 - **``"earliest"``** -- Block #0
 - **``"pending"``** -- The block currently being prepared for mining; not all
-  operations support this BlockTag
+  operations and backends support this BlockTag
 - **//number//** -- The block at this height
 - **//a negative number//** -- The block this many blocks ago
 
-_heading: Network @<provider-network>
+_heading: EventType @<providers-EventType>
+
+And **EventType** can be any of the following.
+
+- **//string//** -- TODO...
+- **//Array<string<[[DataHexString]]<32>> | Array<string<[[DataHexString]]<32>>>>//** -- TODO...
+- **//[[providers-EventFilter]]//** -- TODO...
+
+
+_subsection: Network @<providers-Network>
 A **Network** represents an Etherem network.
 
-- **name** -- The human-readable name of the network
-- **chainId** -- The Chain ID of the network
-- **ensAddress** -- The address at which the ENS registry is deployed
+_property: network.name => string
+The human-readable name of the network, such as ``homestead``. If the network
+name is unknown, this will be ``"unknown"``.
+
+_property: network.chainId => number
+The Chain ID of the network.
+
+_property: network.ensAddress => string<[[address]]>
+The address at which the ENS registry is deployed on this network.
 
 
-_subsection: Blocks
+_subsection: Block @<providers-Block>
 
-_heading: Block @<provider-block>
-TODO
+_property: block.hash => string<[[DataHexString]]<32>>
+The hash of this block.
 
-_heading: BlockWithTransactions @<provider-blocktxs>
-TODO
+_property: block.parentHash => string<[[DataHexString]]<32>>
+The hash of the previous block.
+
+_property: block.number => number
+The height (number) of this block.
+
+_property: block.timestamp => number
+The timestamp of this block.
+
+_property: block.nonce => string<[[DataHexString]]>
+The nonce used as part of the proof-of-work to mine this block.
+
+This property is generally of little interest developers.
+
+_property: block.difficulty => number
+The difficulty target required to be met by the miner of the block.
+
+This property is generally of little interest developers.
+
+_property: block.gasLimit => [[BigNumber]]
+The maximum amount of gas that this block was permitted to use. This
+is a value that can be voted up or voted down by miners and is used
+to automatically adjust the bandwidth requirements of the network.
+
+This property is generally of little interest developers.
+
+_property: block.gasUsed => [[BigNumber]]
+The total amount of gas used by all transactions in this block.
+
+_property: block.miner => string
+The coinbase address of this block, which indicates the address the
+miner that mined this block would like the subsidy reward to go to.
+
+_property: block.extraData => string
+This is extra data a miner may choose to include when mining a block.
+
+This property is generally of little interest developers.
+
+_heading: Block (with transaction hashes)
+
+Often only the hashes of the transactions included in a block are needed,
+so by default a block only contains this information, as it is
+substantially less data.
+
+_property: block.transactions => Array<string<[[DataHexString]]<32>>>
+A list of the transactions hashes for each transaction this block
+includes.
+
+_heading: BlockWithTransactions @<providers-BlockWithTransactions> @INHERIT<[Block](providers-Block)>
+
+If all transactions for a block are needed, this object instead includes
+the full details on each transaction.
+
+_property: block.transactions => Array<[[providers-TransactionResponse]]>
+A list of the transactions this block includes.
 
 
 _subsection: Events and Logs
 
-_heading: EventFilter
-TODO
+_heading: EventFilter @<providers-EventFilter>
 
-_heading: EventType
-TODO
+_property: filter.address => string<[[address]]>
+The address to filter by, or ``null`` to match any address.
 
-_heading: Filter
-TODO
+_property: filter.topics => Array<string<[[DataHexString]]<32>> | Array<string<[[DataHexString]]<32>>>>
+The topics to filter by, or ``null`` to match any topics. Each entry represents an
+**AND** condition that must match, or may be ``null`` to match anything. If a given
+entry is an Array, then that entry is treated as an **OR** for any value in the entry.
 
-_heading: FilterByBlockHash
-TODO
+_heading: Filter @<providers-Filter> @INHERIT<[[providers-EventFilter]]>
 
-_heading: Log @<provider-log>
-A network...
+_property: filter.fromBlock => [[providers-BlockTag]]
+The starting block (inclusive) to search for logs matching the filter criteria.
+
+_property: filter.toBlock => [[providers-BlockTag]]
+The end block (inclusive) to search for logs matching the filter criteria.
+
+_heading: FilterByBlockHash @<providers-FilterByBlockHash> @INHERIT<[[providers-EventFilter]]>
+
+_property: filter.blockHash => string<[[DataHexString]]<32>>
+The specific block (by its block hash) to search for logs matching the filter criteria.
+
+
+_heading: Log @<providers-Log>
+
+_property: log.blockNumber => number
+The block height (number) of the block including the transaction of this log.
+
+_property: log.blockHash => string<[[DataHexString]]<32>>
+The block hash of the block including the transaction of this log.
+
+_property: log.removed => boolean
+During a re-org, if a transaction is orphaned, this will be set to true
+to indicate the Log entry has been removed; it will likely be emitted
+again in the near future when another block is mined with the transaction
+that triggered this log, but keep in mind the values may change.
+
+_property: log.transactionLogIndex => number
+The index of this log in the transaction.
+
+_property: log.address => string<[[address]]>
+The address of the contract that generated this log.
+
+_property: log.data => string<[[DataHexString]]>
+The data included in this log.
+
+_property: log.topics => Array<string<[[DataHexString]]<32> > >
+The list of topics (indexed properties) for this log.
+
+_property: log.transactionHash => string<[[DataHexString]]<32>>
+The transaction hash of the transaction of this log.
+
+_property: log.transactionIndex => number
+The index of the transaction in the block of the transaction of this log.
+
+_property: log.logIndex => number
+The index of this log across all logs in the entire **block**.
 
 
 _subsection: Transactions
 
-_heading: TransactionRequest @<provider-transactionrequest>
+_heading: TransactionRequest @<providers-TransactionRequest>
 
 A transaction request describes a transaction that is to
 be sent to the network or otherwise processed.
 
-It contains the fields:
-- **to** --- target address
-- **from** --- target address
-- **nonce** --- target address
-- **gasLimit** --- target address
-- **gasPrice** --- target address
-- **data** --- target address
-- **value** --- target address
-- **chainId** --- target address
-
 All fields are optional and may be a promise which resolves
 to the required type.
 
-_heading: TransactionResponse @<provider-transactionresponse>
+_property: transactionRequest.to => string | Promise<string>
+The address (or ENS name) this transaction it to.
 
-A **TransactionResponse** ..
+_property: transactionRequest.from => string<[[address]]> | Promise<string<[[address]]>>
+The address this transaction is from.
 
-_heading: TransactionReceipt @<provider-transactionreceipt>
-TODO
+_property: transactionRequest.nonce => number | Promise<number>
+The nonce for this transaction. This should be set to the number of
+transactions ever sent **from** this address.
+
+_property: transactionRequest.gasLimit => [[BigNumber]] | Promise<[[BigNumber]]>
+The maximum amount of gas this transaction is permitted to use.
+
+_property: transactionRequest.gasPrice => [[BigNumber]] | Promise<[[BigNumber]]>
+The price (in wei) per unit of gas this transaction will pay.
+
+_property: transactionRequest.data => [[DataHexString]] | Promise<[[DataHexString]]>
+The transaction data.
+
+_property: transactionRequest.value => [[BigNumber]] | Promise<[[BigNumber]]>
+The amount (in wei) this transaction is sending.
+
+_property: transactionRequest.chainId => number | Promise<number>
+The chain ID this transaction is authorized on, as specified by
+[EIP-155](link-eip-155).
+
+If the chain ID is 0 will disable EIP-155 and the transaction will be valid
+on any network. This can be **dangerous** and care should be taken, since it
+allows transactions to be replayed on networks that were possibly not
+intended.
+
+_heading: TransactionResponse @<providers-TransactionResponse> @INHERIT<[[Transaction]]>
+
+A **TransactionResponse** includes all properties of a [[Transaction]] as well as several
+properties that are useful once it has been mined.
+
+_property: transaction.blockNumber => number
+The number ("height") of the block this transaction was mined in. If the block has not been mined,
+this is ``null``.
+
+_property: transaction.blockHash => string<[[DataHexString]]<32>>
+The hash of the block this transaction was mined in. If the block has not been mined,
+this is ``null``.
+
+_property: transaction.timestamp => number
+The timestamp of the block this transaction was mined in. If the block has not been mined,
+this is ``null``.
+
+_property: transaction.confirmations => number
+The number of blocks that have been mined (including the initial block) since this
+transaction was mined.
+
+_property: transaction.raw => string<[[DataHexString]]>
+The serialized transaction.
+
+_property: transaction.wait([ confirmations = 1 ]) => Promise<[[providers-TransactionReceipt]]>
+Wait for //confirmations//. If 0, and the transaction has not been mined,
+``null`` is returned.
+
+_heading: TransactionReceipt @<providers-TransactionReceipt>
+
+_property: receipt.to => string<[[address]]>
+The address this transaction is to. This is ``null`` if the the
+transaction was an **init transaction**, used to deploy a contract.
+
+_property: receipt.from => string<[[address]]>
+The address this transaction is from.
+
+_property: receipt.contractAddress => string<[[address]]>
+If this transaction has a ``null`` to address, it is an **init transaction**
+used to deploy a contract, in which case this is the address created by that
+contract.
+
+To compute a contract address, the [getContractAddress](utils-getContractAddress)
+utility function can also be used with a [[providers-TransactionResponse]]
+object, which requires the transaction nonce and the address of the sender.
+
+_property: receipt.transactionIndex => number
+The index of this transaction in the list of transactions included in
+the block this transaction was mined in.
+
+_property: receipt.root => string
+The intermediate state root of a receipt.
+
+Only transactions included in blocks **before** the [Byzantium Hard Fork](link-eip-609)
+have this property, as it was replaced by the ``status`` property.
+
+The property is generally of little use to developers. At the time
+it could be used to verify a state transition with a fraud-proof
+only considering the single transaction; without it the full block
+must be considered.
+
+_property: receipt.gasUsed => [[BigNumber]]
+The amount of gas actually used by this transaction.
+
+_property: receipt.logsBloom => string<[[DataHexString]]>
+A [bloom-filter](link-wiki-bloomfilter), which
+incldues all the addresses and topics included in any log in this
+transaction.
+
+_property: receipt.blockHash => string<[[DataHexString]]<32>>
+The block hash of the block that this transaction was included in.
+
+_property: receipt.transactionHash => string<[[DataHexString]]<32>>
+The transaction hash of this transaction.
+
+_property: receipt.logs => Array<[[providers-Log]]>
+All the logs emitted by this transaction.
+
+_property: receipt.blockNumber => number
+The block height (number) of the block that this transaction was
+included in.
+
+_property: receipt.confirmations => number
+The number of blocks that have been mined since this transaction,
+including the actual block it was mined in.
+
+_property: receipt.cumulativeGasUsed => [[BigNumber]]
+For the block this transaction was included in, this is the sum of the
+gas used used by each transaction in the ordered list of transactions
+up to (and including) this transaction.
+
+This is generally of little interest to developers.
+
+_property: receipt.byzantium => boolean
+This is true if the block is in a [post-Byzantium Hard Fork](link-eip-609)
+block.
+
+_property: receipt.status => boolean
+The status of a transaction is 1 is successful or 0 if it was
+reverted. Only transactions included in blocks [post-Byzantium Hard Fork](link-eip-609)
+have this property.

docs.wrm/api/signer.wrm

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

docs.wrm/api/utils/abi/fragments.wrm

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

docs.wrm/api/utils/abi/index.wrm

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

docs.wrm/api/utils/abi/interface.wrm

@@ -0,0 +1,196 @@
+_section: Interface @<Interface> @SRC<abi/interface:class.Interface>
+
+The **Interface** Class abstracts the encoding and decoding required
+to interact with contracts on the Ethereum network.
+
+Many of the standards organically evolved along side the [[link-solidity]]
+language, which other languages have adopted to remain compatibile with
+existing deployed contracts.
+
+The EVM itself does not understand what the ABI is. It is simply an agreed
+upon set of formats to encode various types of data which each contract can
+expect so they can interoperate with each other.
+
+
+_subsection: Creating Instances
+
+_property: new ethers.utils.Interface(abi) @SRC<abi/interface:constructor.Interface>
+Create a new **Interface** from a JSON string or object representing
+//abi//.
+
+The //abi// may be a JSON string or the parsed Object (using JSON.parse)
+which is emitted by the [Solidity compiler](link-solc-output) (or compatible languages).
+
+The //abi// may also be a [Human-Readable Abi](link-ricmoo-humanreadableabi),
+which is a format the Ethers created to simplify manually typing the ABI
+into the source and so that a Contract ABI can also be referenced easily
+within the same source file.
+
+_subsection: Properties
+
+_property: interface.fragments => Array<[[Fragment]]>
+All the [Fragments](Fragment) in the interface.
+
+_property: interface.events => Array<[[EventFragment]]>
+All the [Event Fragments](EventFragment) in the interface.
+
+_property: interface.functions => Array<[[FunctionFragment]]>
+All the [Function Fragments](FunctionFragment) in the interface.
+
+_property: interface.deploy => [[ConstructorFragment]]
+The [Constructor Fragments](ConstructorFragment) for the interface.
+
+
+_subsection: Formatting
+
+_property: interface.format( [ format ]) => string | Array<string> @SRC<abi/interface>
+Return the formatted **Interface**. If the format type is ``json`` a
+single string is returned, otherwise an Array of the human-readable
+strings is returned.
+
+
+_subsection: Fragment Access
+
+_property: interface.getFunction(fragment) => [[FunctionFragment]]  @SRC<abi/interface>
+Returns the [[FunctionFragment]] for //fragment// (see [[Interface--specifying-fragments]]).
+
+_property: interface.getEvent(fragment) => [[EventFragment]] @SRC<abi/interface>
+Returns the [[EventFragment]] for //fragment// (see [[Interface--specifying-fragments]]).
+
+
+_subsection: Signature and Topic Hashes
+
+_property: interface.getSighash(fragment) => string<[[DataHexString]]<4>> @SRC<abi/interface:method.Interface.getSighash>
+Return the sighash (or Function Selector) for //fragment// (see [[Interface--specifying-fragments]]).
+
+_property: interface.getEventTopic(fragment) => string<[[DataHexString]]<32>> @SRC<abi/interface:method.Interface.getEventTopic>
+Return the topic hash for //fragment// (see [[Interface--specifying-fragments]]).
+
+
+_subsection: Encoding Data
+
+_property: interface.encodeDeploy([ values ]) => string<[[DataHexString]]> @SRC<abi/interface>
+Return the encoded deployment data, which can be concatenated to the
+deployment bytecode of a contract to pass //values// into the contract
+constructor.
+
+_property: interface.encodeFilterTopics(fragment [ , values ]) => Array<topic | Array<topic>> @SRC<abi/interface>
+Returns the encoded topic filter, which can be passed to getLogs for //fragment//
+(see [[Interface--specifying-fragments]]) for the given //values//.
+
+Each //topic// is a 32 byte (64 nibble) [[DataHexString]].
+
+_property: interface.encodeFunctionData(fragment [ , values ]) => string<[[DataHexString]]> @SRC<abi/interface>
+Returns the encoded data, which can be used as the data for a transaction for
+//fragment// (see [[Interface--specifying-fragments]]) for the given //values//.
+
+_property: interface.encodeFunctionResult(fragment [ , values ]) => string<[[DataHexString]]> @SRC<abi/interface>
+Returns the encoded result, which would normally be the response from a call for
+//fragment// (see [[Interface--specifying-fragments]]) for the given //values//.
+
+Most developers will not need this method, but may be useful for authors of a mock blockchain.
+
+
+_subsection: Decoding Data
+
+_property: interface.decodeEventLog(fragment, data [ , topics ]) => [[Result]] @SRC<abi/interface>
+Returns the decoded event values from an event log for
+//fragment// (see [[Interface--specifying-fragments]]) for the given //data//
+with the optional //topics//.
+
+If //topics// is not specified, placeholders will be inserted into the result.
+
+_property: interface.decodeFunctionData(fragment, data) => [[Result]] @SRC<abi/interface>
+Returns the decoded values from transaction data for
+//fragment// (see [[Interface--specifying-fragments]]) for the given //data//.
+
+Most developers will not need this method, but may be useful for debugging
+or inspecting transactions.
+
+_property: interface.decodeFunctionResult(fragment, data) => [[Result]] @SRC<abi/interface>
+Returns the decoded values from the result of a call for
+//fragment// (see [[Interface--specifying-fragments]]) for the given //data//.
+
+
+_subsection: Parsing
+
+The functions are generally the most useful for most developers. They will
+automatically search the ABI for a matching Event or Function and decode
+the components as a fully specified description.
+
+_property: interface.parseLog(log) => [[LogDescription]] @SRC<abi/interface>
+Search the event that matches the //log// topic hash and parse the values
+the log represents.
+
+_property: interface.parseTransaction(transaction) => [[TransactionDescription]] @SRC<abi/interface>
+Search for the function that matches the //transaction// data sighash
+and parse the transaction properties.
+
+
+_subsection: Types
+
+_heading: Result @<Result> @INHERIT<Array\<any\>>
+
+A **Result** is an array, so each value can be accessed as a positional
+argument.
+
+Additionally, if values are named, the identical object as its positional
+value can be accessed by its name.
+
+The name ``length`` is however reserved as it is part of the Array, so
+any named value for this key is renamed to ``_length``. If there is a
+name collision, only the first is available by its key.
+
+
+_heading: LogDescription @<LogDescription>
+
+_property: logDescription.args => [[Result]]
+The values of the input parameters of the event.
+
+_property: logDescription.eventFragment => [[EventFragment]]
+The [[EventFragment]] which matches the topic in the Log.
+
+_property: logDescription.name => string
+The event name. (e.g. ``Transfer``)
+
+_property: logDescription.signature => string
+The event signature. (e.g. ``Transfer(address,address,uint256)``)
+
+_property: logDescription.topic => string
+The topic hash.
+
+
+_heading: TransactionDescription @<TransactionDescription>
+
+_property: transactionDescription.args => [[Result]]
+The decoded values from the transaction data which were passed
+as the input parameters.
+
+_property: transactionDescription.functionFragment => [[FunctionFragment]]
+The [[FunctionFragment]] which matches the sighash in the transaction data.
+
+_property: transactionDescription.name => string
+The name of the function. (e.g. ``transfer``)
+
+_property: transactionDescription.sighash => string
+The sighash (or function selector) that matched the transaction data.
+
+_property: transactionDescription.signature => string
+The signature of the function. (e.g. ``transfer(address,uint256)``)
+
+_property: transactionDescription.value => [[BigNumber]]
+The value from the transaction.
+
+
+_subsection: Specifying Fragments @<Interface--specifying-fragments>
+
+When specifying a fragment to any of the functions in an **Interface**,
+any of the following may be used:
+
+- The **name** of the event or function, if it is unique and non-ambiguous
+  within the ABI (e.g. ``transfer``)
+- The **signature** of the event or function. The signature is normalized,
+  so, for example, ``uint`` and ``uint256`` are equivalent (e.g. ``transfer(address, uint)``)
+- The **sighash** or **topichash** of the function. The sighash is often referred
+  to the function selector in Solidity (e.g. ``0xa9059cbb``)
+- A [[Fragment]]

docs.wrm/api/utils/address.wrm

@@ -1,5 +1,3 @@
-_title: Addresses
-
 _section: Addresses @<addresses>
 
 Explain addresses,formats and checksumming here.
@@ -8,34 +6,78 @@ Also see: [constants.AddressZero](constants)
 
 _subsection: Address Formats  @<address-formats>
 
-_heading: Checksum Address  @<address>
-TODO
+
+_heading: Address  @<address>
+
+An **Address** is a [[DataHexString]] of 20 bytes (40 nibbles), with optional
+mixed case.
+
+If the case is mixed, it is a **Checksum Address**, which uses a specific pattern
+of uppercase and lowercase letters within a given address to reduce the risk
+of errors introduced from typing an address or cut and paste issues.
+
+All functions that return an Address will return a Checksum Address.
+
 
 _heading: ICAP Address  @<address-icap>
-TODO
 
-_subsection: Functions
+The **ICAP Address Format** was an early attempt to introduce a checksum
+into Ethereum addresses using the popular banking industry's
+[IBAN](link-wiki-iban)
+format with the country code specified as **XE**.
 
-_property: utils.getAddress(address) => string<[Address](address)>  @<utils-getAddress> @SRC<address>
+Due to the way IBAN encodes address, only addresses that fit into 30 base-36
+characters are actually compatible, so the format was adapted to support 31
+base-36 characters which is large enough for a full Ethereum address, however
+the preferred method was to select a private key whose address has a ``0`` as
+the first byte, which allows the address to be formatted as a fully compatibly
+standard IBAN address with 30 base-36 characters.
+
+In general this format is no longer widely supported anymore, however any function that
+accepts an address can receive an ICAP address, and it will be converted internally.
+
+To convert an address into the ICAP format, see [getIcapAddress](utils-getIcapAddress).
+
+
+_subsection: Converting and Verifying @<utils--address>
+
+_property: ethers.utils.getAddress(address) => string<[[address]]>  @<utils-getAddress> @SRC<address>
 Returns //address// as a Checksum Address.
 
-If //address// is an invalid 40-nibble [[hexstring]] or if it contains mixed case and
+If //address// is an invalid 40-nibble [[HexString]] or if it contains mixed case and
 the checksum is invalid, an InvalidArgument Error is throw.
 
 The value of //address// may be any supported address format.
 
-
-_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).
+_property: ethers.utils.getIcapAddress(address) => string<[IcapAddress](address-icap)>  @<utils-getIcapAddress> @SRC<address>
+Returns //address// as an [ICAP address](link-icap).
 Supports the same restrictions as [utils.getAddress](utils-getAddress).
 
-_property: utils.getContractAddress(transaction) => string<[Address](address)>  @<utils-getContractAddress> @SRC<address>
+_property: ethers.utils.isAddress(address) => boolean  @<utils-isAddress> @SRC<address>
+Returns true if //address// is valid (in any supported format).
+
+
+_subsection: Derivation @<utils--address-derivation>
+
+_property: ethers.utils.computeAddress(publicOrPrivateKey) => string<[[address]]>  @<utils-computeAddress> @SRC<transactions>
+Returns the address for //publicOrPrivateKey//. A public key may be
+compressed or uncompressed, and a private key will be converted
+automatically to a public key for the derivation.
+
+_property: ethers.utils.recoverAddress(digest, signature) => string<[[address]]>  @<utils-recoverAddress> @SRC<transactions>
+Use [[link-wiki-ecrecover]] to determine the address that signed //digest// to
+which generated //signature//.
+
+
+_subsection: Contracts Addresses @<utils--contract-addresses>
+
+_property: ethers.utils.getContractAddress(transaction) => string<[[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>
+_property: ethers.utils.getCreate2Address(from, salt, initCodeHash) => string<[[address]]> @<utils-getCreate2Address> @SRC<address>
 Returns the contract address that would result from the given
-[CREATE2](https://eips.ethereum.org/EIPS/eip-1014) call.
+[CREATE2](link-eip-1014) call.
+
+
+

docs.wrm/api/utils/bignumber-create.js

@@ -1,50 +0,0 @@
-// <hide>
-const { BigNumber } = require("./packages/ethers");
-const { constants } = require("./packages/ethers");
-
-function _inspect(result) {
-    if (BigNumber.isBigNumber(result)) {
-        return `{ BigNumber: ${ JSON.stringify(result.toString()) } }`;
-    }
-    return result;
-}
-// </hide>
-
-// From a decimal string...
-BigNumber.from("42")
-//!
-
-// From a hexstring...
-BigNumber.from("0x2a")
-//!
-
-// From a negative hexstring...
-BigNumber.from("-0x2a")
-//!
-
-// From an Array (or Uint8Array)...
-BigNumber.from([ 42 ])
-//!
-
-// From an existing BigNumber...
-let one1 = constants.One;
-let one2 = BigNumber.from(one1)
-
-one2
-//!
-
-// ...which returns the same instance
-one1 === one2
-//!
-
-// From a (safe) number...
-BigNumber.from(42)
-//!
-
-// From a ES2015 BigInt... (only on platforms with BigInt support)
-BigNumber.from(42n)
-//!
-
-// Numbers outside the safe range fail:
-BigNumber.from(Number.MAX_SAFE_INTEGER);
-//! error

docs.wrm/api/utils/bignumber-examples.js

@@ -1,16 +0,0 @@
-// <hide>
-const { BigNumber } = require("./packages/ethers");
-
-function _inspect(result) {
-    if (BigNumber.isBigNumber(result)) {
-        return `{ BigNumber: ${ JSON.stringify(result.toString()) } }`;
-    }
-    return result;
-}
-// </hide>
-
-let a = BigNumber.from(42);
-let b = BigNumber.from("91");
-
-  a.mul(b);
-  //!

docs.wrm/api/utils/bignumber-ieee754.js

@@ -1,2 +0,0 @@
-(Number.MAX_SAFE_INTEGER + 2 - 2) == (Number.MAX_SAFE_INTEGER)
-//!

docs.wrm/api/utils/bignumber-import.source

@@ -1,18 +0,0 @@
-/////
-// CommonJS:
-
-// From the Umbrella ethers package...
-const { BigNumber } = require("ethers");
-
-// From the bignumber pacakge...
-const { BigNumber } = require("@ethersproject/bignumber");
-
-
-/////
-// ES6 and TypeScript:
-
-// From the Umbrella ethers package...
-import { BigNumber } from "ethers";
-
-// From the bignumber pacakge...
-import { BigNumber } from "@ethersproject/bignumber";

docs.wrm/api/utils/bignumber.wrm

@@ -1,37 +1,59 @@
-_title: Big Number
+_section: BigNumber @<BigNumber>
 
+Many operations in Ethereum operation on numbers which are
+[outside the range of safe values](BigNumber--notes-safenumbers) to use
+in JavaScript.
 
-_section: BigNumber @<bignumber>
+A **BigNumber** is an object which safely allows mathematic operations
+on numbers of any magnitude.
+
+Most operations which need to return a value will return a **BigNumber**
+and parameters which accept values will generally accept them.
 
-Explain about BigNumber here...
 
 _heading: Importing
 
-_code: bignumber-import.source
+_code: CommonJS @lang<script>
+
+// From the Umbrella ethers package...
+const { BigNumber } = require("ethers");
+
+// From the BigNumber pacakge...
+const { BigNumber } = require("@ethersproject/BigNumber");
+
+
+_code: ES6 and TypeScript CommonJS @lang<script>
+
+// From the Umbrella ethers package...
+import { BigNumber } from "ethers";
+
+// From the BigNumber pacakge...
+import { BigNumber } from "@ethersproject/BigNumber";
+
 
 _subsection: Types
 
-_heading: BigNumberish @<bignumberish>
+_heading: BigNumberish @<BigNumberish>
 
 Many functions and methods in this library take in values which
 can be non-ambiguously and safely converted to a BigNumber. These
 values can be sepcified as:
 
 _definition: **//string//**
-A [hexstring](hexstring) or a decimal string, either of which may
+A [[HexString]] or a decimal string, either of which may
 be negative.
 
 _definition: **//BytesLike//**
-A [BytesLike](byteslike) Object, such as an Array or Uint8Array.
+A [[BytesLike]] Object, such as an Array or Uint8Array.
 
 _definition: **//BigNumber//**
-An existing BigNumber instance.
+An existing [[BigNumber]] instance.
 
 _definition: **//number//**
-A number that is within the safe range for JavaScript numbers.
+A number that is within the [safe range](link-js-maxsafe) for JavaScript numbers.
 
 _definition: **//BigInt//**
-A JavaScript [BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt)
+A JavaScript [BigInt](link-js-bigint)
 object, on environments that support BigInt.
 
 
@@ -39,12 +61,51 @@ _subsection: Creating Instances
 
 The constructor of BigNumber cannot be called directly. Instead, Use the static ``BigNumber.from``.
 
-_property: BigNumber.from(aBigNumberish) => [[bignumber]]
+_property: ethers.BigNumber.from(aBigNumberish) => [[BigNumber]]
 Returns an instance of a **BigNumber** for //aBigNumberish//.
 
-_heading: Examples:
+_heading: Examples:  @<>
 
-_code: bignumber-create.js
+_code: @lang<javascript>
+
+// From a decimal string...
+BigNumber.from("42")
+//!
+
+// From a HexString...
+BigNumber.from("0x2a")
+//!
+
+// From a negative HexString...
+BigNumber.from("-0x2a")
+//!
+
+// From an Array (or Uint8Array)...
+BigNumber.from([ 42 ])
+//!
+
+// From an existing BigNumber...
+let one1 = constants.One;
+let one2 = BigNumber.from(one1)
+
+one2
+//!
+
+// ...which returns the same instance
+one1 === one2
+//!
+
+// From a (safe) number...
+BigNumber.from(42)
+//!
+
+// From a ES2015 BigInt... (only on platforms with BigInt support)
+BigNumber.from(42n)
+//!
+
+// Numbers outside the safe range fail:
+BigNumber.from(Number.MAX_SAFE_INTEGER);
+//! error
 
 
 _subsection: Methods
@@ -55,98 +116,106 @@ it represents.
 
 _heading: Math Operations
 
-_property: bignumber.add(otherValue) => [[bignumber]]  @SRC<bignumber>
-Returns a BigNumber with the value of //bignumber// **+** //otherValue//.
+_property: BigNumber.add(otherValue) => [[BigNumber]]  @SRC<bignumber>
+Returns a BigNumber with the value of //BigNumber// **+** //otherValue//.
 
-_property: bignumber.sub(otherValue) => [[bignumber]]  @SRC<bignumber>
-Returns a BigNumber with the value of //bignumber// **&ndash;** //otherValue//.
+_property: BigNumber.sub(otherValue) => [[BigNumber]]  @SRC<bignumber>
+Returns a BigNumber with the value of //BigNumber// **-** //otherValue//.
 
-_property: bignumber.mul(otherValue) => [[bignumber]]  @SRC<bignumber>
-Returns a BigNumber with the value of //bignumber// **&times;** //otherValue//.
+_property: BigNumber.mul(otherValue) => [[BigNumber]]  @SRC<bignumber>
+Returns a BigNumber with the value of //BigNumber// **&times;** //otherValue//.
 
-_property: bignumber.div(divisor) => [[bignumber]]  @SRC<bignumber>
-Returns a BigNumber with the value of //bignumber// **&#247;** //divisor//.
+_property: BigNumber.div(divisor) => [[BigNumber]]  @SRC<bignumber>
+Returns a BigNumber with the value of //BigNumber// **&div;** //divisor//.
 
-_property: bignumber.mod(divisor) => [[bignumber]]  @SRC<bignumber>
-Returns a BigNumber with the value of the **remainder** of //bignumber// &#247; //divisor//.
+_property: BigNumber.mod(divisor) => [[BigNumber]]  @SRC<bignumber>
+Returns a BigNumber with the value of the **remainder** of //BigNumber// &div; //divisor//.
 
-_property: bignumber.pow(exponent) => [[bignumber]]  @SRC<bignumber>
-Returns a BigNumber with the value of //bignumber// to the power of //exponent//.
+_property: BigNumber.pow(exponent) => [[BigNumber]]  @SRC<bignumber>
+Returns a BigNumber with the value of //BigNumber// to the power of //exponent//.
 
-_property: bignumber.abs() => [[bignumber]]  @SRC<bignumber>
-Returns a BigNumber with the absolute value of //bignumber//.
+_property: BigNumber.abs() => [[BigNumber]]  @SRC<bignumber>
+Returns a BigNumber with the absolute value of //BigNumber//.
 
-_property: bignumber.maskn(bitcount) => [[bignumber]]  @SRC<bignumber>
-Returns a BigNumber with the value of //bignumber// with bits beyond
+_property: BigNumber.mask(bitcount) => [[BigNumber]]  @SRC<bignumber>
+Returns a BigNumber with the value of //BigNumber// with bits beyond
 the //bitcount// least significant bits set to zero.
 
 
 _heading: Two's Compliment
 
-[Two's Complicment](https://en.wikipedia.org/wiki/Two%27s_complement)
+[Two's Complicment](link-wiki-twoscomplement)
 is an elegant method used to encode and decode fixed-width signed values
 while efficiently preserving mathematic operations.
 Most users will not need to interact with these.
 
-_property: bignumber.fromTwos(bitwidth) => [[bignumber]]  @SRC<bignumber>
-Returns a BigNumber with the value of //bignumber// converted from twos-compliment with //bitwidth//.
+_property: BigNumber.fromTwos(bitwidth) => [[BigNumber]]  @SRC<bignumber>
+Returns a BigNumber with the value of //BigNumber// converted from twos-compliment with //bitwidth//.
 
-_property: bignumber.toTwos(bitwidth) => [[bignumber]]  @SRC<bignumber>
-Returns a BigNumber with the value of //bignumber// converted to twos-compliment with //bitwidth//.
+_property: BigNumber.toTwos(bitwidth) => [[BigNumber]]  @SRC<bignumber>
+Returns a BigNumber with the value of //BigNumber// converted to twos-compliment with //bitwidth//.
 
 
 _heading: Comparison and Equivalence
 
-_property: bignumber.eq(otherValue) => boolean  @SRC<bignumber>
-Returns true if and only if the value of //bignumber// is equal to //otherValue//.
+_property: BigNumber.eq(otherValue) => boolean  @SRC<bignumber>
+Returns true if and only if the value of //BigNumber// is equal to //otherValue//.
 
-_property: bignumber.lt(otherValue) => boolean  @SRC<bignumber>
-Returns true if and only if the value of //bignumber// **<** //otherValue//.
+_property: BigNumber.lt(otherValue) => boolean  @SRC<bignumber>
+Returns true if and only if the value of //BigNumber// **<** //otherValue//.
 
-_property: bignumber.lte(otherValue) => boolean  @SRC<bignumber>
-Returns true if and only if the value of //bignumber// **&le;** //otherValue//.
+_property: BigNumber.lte(otherValue) => boolean  @SRC<bignumber>
+Returns true if and only if the value of //BigNumber// **&le;** //otherValue//.
 
-_property: bignumber.gt(otherValue) => boolean  @SRC<bignumber>
-Returns true if and only if the value of //bignumber// **>** //otherValue//.
+_property: BigNumber.gt(otherValue) => boolean  @SRC<bignumber>
+Returns true if and only if the value of //BigNumber// **>** //otherValue//.
 
-_property: bignumber.gte(otherValue) => boolean  @SRC<bignumber>
-Returns true if and only if the value of //bignumber// **&ge;** //otherValue//.
+_property: BigNumber.gte(otherValue) => boolean  @SRC<bignumber>
+Returns true if and only if the value of //BigNumber// **&ge;** //otherValue//.
 
-_property: bignumber.isZero() => boolean  @SRC<bignumber>
-Returns true if and only if the value of //bignumber// is zero.
+_property: BigNumber.isZero() => boolean  @SRC<bignumber>
+Returns true if and only if the value of //BigNumber// is zero.
 
 
 _heading: Conversion
 
-_property: bignumber.toNumber() => number  @SRC<bignumber>
-Returns the value of //bignumber// as a JavaScript value.
+_property: BigNumber.toNumber() => number  @SRC<bignumber>
+Returns the value of //BigNumber// as a JavaScript value.
 
 This will **throw an error**
 if the value is greater than or equal to //Number.MAX_SAFE_INTEGER// or less than or
 equal to //Number.MIN_SAFE_INTEGER//.
 
-_property: bignumber.toString() => string  @SRC<bignumber:BigNumber.toString>
-Returns the value of //bignumber// as a base-10 string.
+_property: BigNumber.toString() => string  @SRC<bignumber:BigNumber.toString>
+Returns the value of //BigNumber// as a base-10 string.
 
-_property: bignumber.toHexString() => string<[[datahexstring]]>  @SRC<bignumber:BigNumber.toHexString>
-Returns the value of //bignumber// as a base-16, `0x`-prefixed [hexstring](hexstring).
+_property: BigNumber.toHexString() => string<[[DataHexString]]>  @SRC<bignumber:BigNumber.toHexString>
+Returns the value of //BigNumber// as a base-16, ``0x``-prefixed [[DataHexString]].
 
 
 _heading: Inspection
 
-_property: BigNumnber.isBigNumber(object) => boolean  @SRC<bignumber>
+_property: ethers.BigNumnber.isBigNumber(object) => boolean  @SRC<bignumber>
 Returns true if and only if the //object// is a BigNumber object.
 
 
 _heading: Examples
 
-_code: bignumber-examples.js
+_code: @lang<javascript>
+
+let a = BigNumber.from(42);
+let b = BigNumber.from("91");
+
+a.mul(b);
+//!
+
 
 _subsection: Notes
 
-A few short notes on numbers...
+This section is a for a couple of questions that come up frequently.
 
-_heading: Why can't I just use numbers?
+
+_heading: Why can't I just use numbers? @<BigNumber--notes-safenumbers>
 
 The first problem many encounter when dealing with Ethereum is
 the concept of numbers. Most common currencies are broken down
@@ -154,7 +223,7 @@ with very little granularity. For example, there are only 100
 cents in a single dollar. However, there are 10^^18^^ **wei** in a
 single **ether**.
 
-JavaScript uses [IEEE 754 double-precision binary floating point](https://en.wikipedia.org/wiki/Double-precision_floating-point_format)
+JavaScript uses [IEEE 754 double-precision binary floating point](link-wiki-ieee754)
 numbers to represent numeric values. As a result, there are //holes//
 in the integer set after 9,007,199,254,740,991; which is
 problematic for //Ethereum// because that is only around 0.009
@@ -163,13 +232,76 @@ experience rounding errors.
 
 To demonstrate how this may be an issue in your code, consider:
 
-_code: bignumber-ieee754.js
+_code: @lang<javascript>
+
+(Number.MAX_SAFE_INTEGER + 2 - 2) == (Number.MAX_SAFE_INTEGER)
+//!
+
+_null:
 
 To remedy this, all numbers (which can be large) are stored
-and manipulated as [Big Numbers](bignumber).
+and manipulated as [Big Numbers](BigNumber).
 
-The functions [parseEther( etherString )](http://linkto) and
-[formatEther( wei )](http://linkto) can be used to convert
+The functions [parseEther( etherString )](utils-parseEther) and
+[formatEther( wei )](utils-formatEther) can be used to convert
 between string representations, which are displayed to or entered
 by the user and Big Number representations which can have
 mathematical operations handled safely.
+
+
+_heading: Why not BigNumber.js, BN.js, BigDecimal, etc?
+
+Everyone has their own favourite Big Number library, and once someone
+has choosen one, it becomes part of their identity, like their editor,
+vi vs emacs. There are over 100 Big Number libraries on [npm](link-npm-query-bignumber).
+
+One of the biggest differences between the Ethers [[BigNumber]] object and
+other libraries is that it is immutable, which is very important when
+dealing with the asynchronous nature of the blockchain.
+
+Capturing the value is not safe in async functions, so immutability
+protects us from easy to make mistakes, which is not possible on the
+low-level library's objects which supports myriad in-place operations.
+
+Second, the Ethers [[BigNumber]] provides all the functionality required
+internally and should generally be sufficient for most developers while
+not exposing some of the more advanced and rare functionality. So it will
+be eaiser to swap out the underlying library without impacting consumers.
+
+For example, if [[link-npm-bnjs]] was exposed, someone may use the
+greatest-common-denominator functions, which would then be functionality
+the replacing library should also provide to ensure anyone depending on
+that functionality is not broken.
+
+
+_heading: Why BN.js??
+
+The reason why [[link-npm-bnjs]] is used internally as the big
+number is because that is the library used by [[link-npm-elliptic]].
+
+Therefore it **must** be included regardless, so we leverage that
+library rather than adding another Big Number library, which would
+mean two different libraries offering the same functionality.
+
+This has saved about 85kb (80% of this library size) of library size
+over other libraries which include separate Big Number libraries for
+various purposes.
+
+
+_heading: Allow us to set a global Big Number library?
+
+Another comment that comes up frequently is tha desire to specify a
+global user-defined Big Number library, which all functions would
+return.
+
+This becomes problematic since your code may live along side other
+libraries or code that use Ethers. In fact, even Ethers uses a lot
+of the public functions internally.
+
+If you, for example, used a library that used ``a.plus(b)`` instead
+of ``a.add(b)``, this would break Ethers when it tries to compute
+fees internally, and other libraries likely have similar logic.
+
+But, the [[BigNumber]] prototype is exposed, so you can always add a
+``toMyCustomBigNumber()`` method to all [[BigNumber]]'s globally
+which is safe.

docs.wrm/api/utils/bytes-conversion.js

@@ -1,37 +0,0 @@
-// <hide>
-
-const { ethers } = require("./packages/ethers");
-const { arrayify, hexlify, hexValue } = ethers.utils;
-
-function _inspect(result) {
-    if (result && typeof(result.length) === "number" && typeof(result) !== "string") {
-        return "[ " + Array.prototype.map.call(result, (i) => _inspect(i)).join(", ") + " ]";
-    }
-    return result;
-}
-
-// </hide>
-
-// Convert a hexstring to a Uint8Array
-arrayify("0x1234")
-//!
-
-// Convert an Array to a hexstring
-hexlify([1, 2, 3, 4])
-//!
-
-// Convert an Object to a hexstring
-hexlify({ length: 2, "0": 1, "1": 2 })
-//!
-
-// Convert an Array to a hexstring
-hexlify([ 1 ])
-//!
-
-// Convert a number to a stripped hex value
-hexValue(1)
-//!
-
-// Convert an Array to a stripped hex value
-hexValue([ 1, 2 ])
-//!

docs.wrm/api/utils/bytes.wrm

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

docs.wrm/api/utils/constants-import.js

@@ -1,3 +0,0 @@
-
-//const { constants } = require("ethers");
-// const { constants } = require("@ethersproject/constants");

docs.wrm/api/utils/constants.wrm

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

docs.wrm/api/utils/display-logic.wrm

@@ -1,5 +1,3 @@
-_title: Display Logic and Input
-
 _section: Display Logic and Input
 
 When creating an Application, it is useful to convert between
@@ -12,10 +10,10 @@ gas prices in gwei for the User Interface, but when sending
 a transaction, both must be specified in wei.
 
 The [parseUnits](unit-conversion) will parse a string representing
-ether, such as ``1.1`` into a [BigNumber](bignumber) in wei, and is
+ether, such as ``1.1`` into a [BigNumber](BigNumber) in wei, and is
 useful when a user types in a value, such as sending 1.1 ether.
 
-The [formatUnits](unit-conversion) will format a [BigNumberish](bignumberish)
+The [formatUnits](unit-conversion) will format a [BigNumberish](BigNumberish)
 into a string, which is useful when displaying a balance.
 
 
@@ -23,46 +21,52 @@ _subsection: Units
 
 _heading: Decimal Count
 
-The //unit// specified may be an integer, which indicates how
-many decimal place the unit has. For example, 1 ether has 18 decimal
-places for wei, and if this library were used with Bitcoin, 1 BTC
-has 8 decimal places for satoshis.
+A **Unit** can be specified as an number, which indicates the
+number of decimal places that should be used.
+
+**Examples:**
+
+- 1 ether in wei, has **18** decimal places (i.e. 1 ether represents 10^^18^^ wei)
+- 1 bitcoin in Satoshi, has **8** decimal places (i.e. 1 bitcoin represents 10^^8^^ satoshi)
 
 _heading: Named Units
 
-In addition to specifying //unit// as a number of decimals, there
-are several common units, which can be passed in as a string:
+There are also several common **Named Units**, in which case their name (as
+a string) may be used.
 
-- **wei** --- 0
-- **kwei** --- 3
-- **mwei** --- 6
-- **gwei** --- 9
-- **szabo** --- 12
-- **finney** --- 15
-- **ether** --- 18
+_table: @STYLE<compact>
+
+|  **Name**    |  **Decimals**  |
+|  //wei//     |      0         |
+|  //kwei//    |      3         |
+|  //mwei//    |      6         |
+|  //gwei//    |      9         |
+|  //szabo//   |     12         |
+|  //finney//  |     15         |
+|  //ether//   |     18         |
 
 
 _subsection: Functions
 
 _heading: Formatting
 
-_property: utils.commify(value) => string  @<util-commify> @SRC<units>
+_property: ethers.utils.commify(value) => string  @<utils-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  @<util-formatunits> @SRC<units>
+_property: ethers.utils.formatUnits(value [ , unit = "ether" ] ) => string  @<utils-formatUnits> @SRC<units>
 Returns a string representation of //value// formatted with //unit//
 digits (if it is a number) or to the unit specified (if a string).
 
-_property: utils.formatEther(value) => string  @<util-formatether> @SRC<units>
+_property: ethers.utils.formatEther(value) => string  @<utils-formatEther> @SRC<units>
 The equivalent to calling ``formatUnits(value, "ether")``.
 
-_property: utils.parseUnits(value [ , unit = "ether" ] ) => [BigNumber](bignumber)  @<util-parseunits> @SRC<units>
-Returns a [BigNumber](bignumber) representation of //value//, parsed with
+_property: ethers.utils.parseUnits(value [ , unit = "ether" ] ) => [BigNumber](BigNumber)  @<utils-parseUnits> @SRC<units>
+Returns a [BigNumber](BigNumber) representation of //value//, parsed with
 //unit// digits (if it is a number) or from the unit specified (if
 a string).
 
-_property: utils.parseEther(value) => [BigNumber](bignumber)  @<util-parseether> @SRC<units>
+_property: ethers.utils.parseEther(value) => [BigNumber](BigNumber)  @<utils-parseEther> @SRC<units>
 The equivalent to calling ``parseUnits(value, "ether")``.

docs.wrm/api/utils/encoding.wrm

@@ -1,21 +1,49 @@
-_title: Encoding Utilies
+_section: Encoding Utilities @<encoding>
 
-_section: Encoding Utilities
-
-_property: utils.base58.decode(textData) => Uin8Array
+_subsection: Base58 @<Bse58> @SRC<basex:Base58>
 
+_property: ethers.utils.base58.decode(textData) => Uin8Array
 Return a typed Uint8Array representation of //textData// decoded using
 base-58 encoding.
 
-_property: utils.base58.encode(aBytesLike) => string
-
+_property: ethers.utils.base58.encode(aBytesLike) => string
 Return //aBytesLike// encoded as a string using the base-58 encoding.
 
-_property: utils.base64.decode(textData) => Uin8Array
 
+_subsection: Base64 @<Base64>
+
+_property: ethers.utils.base64.decode(textData) => Uin8Array  @SRC<base64>
 Return a typed Uint8Array representation of //textData// decoded using
 base-64 encoding.
 
-_property: utils.base64.encode(aBytesLike) => string
-
+_property: ethers.utils.base64.encode(aBytesLike) => string  @SRC<base64>
 Return //aBytesLike// encoded as a string using the base-64 encoding.
+
+
+_subsection: Recursive-Length Prefix @<rlp--methods>
+
+The [[link-rlp]] encoding is used throughout Ethereum to serialize nested
+structures of Arrays and data.
+
+_property: ethers.utils.RLP.encode(dataObject) => string<[[DataHexString]]>  @<utils-rlpEncode> @SRC<rlp>
+Encode a structured Data Object into its RLP-encoded representation.
+
+Each Data component may be an valid [[BytesLike]].
+
+_property: ethers.utils.RLP.decode(aBytesLike) => [DataObject](rlp--dataobject)  @<utils.rlpDecode> @SRC<rlp>
+Decode an RLP-encoded //aBytesLike// into its structured Data Object.
+
+All Data components will be returned as a [[DataHexString]].
+
+_heading: Data Object @<rlp--dataobject>
+
+A **Data Object** is a recursive structure which is used to serialize many
+internal structures in Ethereum. Each **Data Object** can either be:
+
+- Binary Data
+- An Array of **Data Objects** (i.e. this recursively includes Nesting)
+
+_definition: **Examples**
+
+- ``"0x1234"``
+- ``[ "0x1234", [ "0xdead", "0xbeef" ], [ ] ]``

docs.wrm/api/utils/fixednumber.wrm

@@ -1,108 +1,61 @@
-_title: Fixed Number
+_section: FixedNumber @<FixedNumber>
 
-_section: FixedNumber @<fixednumber>
-
-_subsection: FixedFormat @<fixedformat>
-
-A **FixedFormat** is a simple object which represents a decimal
-(base-10) Fixed-Point data representation. Usually using this
-class directly is uneccessary, as passing in a [[fixedformatstring]]
-directly into the [[fixednumber]] will automatically create this.
-
-_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
-
-
-_definition: **//"fixed"//**
-A shorthand for ``fixed128x80``.
+A **FixedNumber** is a fixed-width (in bits) number with an internal
+base-10 divisor, which allows it to represent a decimal fractional
+component.
 
 _subsection: Creating Instances
 
 The FixedNumber constructor cannot be called directly. There are several
 static methods for creating a FixedNumber.
 
-_property: FixedNumber.from(value [ , format = "fixed" ] ) => [[fixednumber]]  @SRC<bignumber:FixedNumber.from>
+_property: FixedNumber.from(value [ , format = "fixed" ] ) => [[FixedNumber]]  @SRC<bignumber:FixedNumber.from>
 Returns an instance of a **FixedNumber** for //value// as a //format//.
 
-_property: FixedNumber.fromBytes(aBytesLike [ , format = "fixed" ] ) => [[fixednumber]]  @SRC<bignumber>
+_property: FixedNumber.fromBytes(aBytesLike [ , format = "fixed" ] ) => [[FixedNumber]]  @SRC<bignumber>
 Returns an instance of a **FixedNumber** for //value// as a //format//.
 
-_property: FixedNumber.fromString(value [ , format = "fixed" ] ) => [[fixednumber]]  @SRC<bignumber:FixedNumber.fromString>
+_property: FixedNumber.fromString(value [ , format = "fixed" ] ) => [[FixedNumber]]  @SRC<bignumber:FixedNumber.fromString>
 Returns an instance of a **FixedNumber** for //value// as a //format//. The //value// must
 not contain more decimals than the //format// permits.
 
-_property: FixedNumber.fromValue(value [ , decimals = 0 [ , format = "fixed" ] ] ) => [[fixednumber]]  @SRC<bignumber:FixedNumber.fromValue>
+_property: FixedNumber.fromValue(value [ , decimals = 0 [ , format = "fixed" ] ] ) => [[FixedNumber]]  @SRC<bignumber:FixedNumber.fromValue>
 Returns an instance of a **FixedNumber** for //value// with //decimals// as a //format//.
 
 
 _subsection: Properties
 
 _property: fixednumber.format
-The [FixedFormat](fixedformat) of //fixednumber//.
+The [FixedFormat](FixedFormat) of //fixednumber//.
 
 
 _subsection: Methods
 
 _heading: Math Operations
 
-_property: fixednumber.addUnsafe(otherValue) => [[fixednumber]]  @SRC<bignumber/fixednumber>
+_property: fixednumber.addUnsafe(otherValue) => [[FixedNumber]]  @SRC<bignumber/fixednumber>
 Returns a new FixedNumber with the value of //fixedvalue// **+** //otherValue//.
 
-_property: fixednumber.subUnsafe(otherValue) => [[fixednumber]]  @SRC<bignumber/fixednumber>
-Returns a new FixedNumber with the value of //fixedvalue// **&ndash;** //otherValue//.
+_property: fixednumber.subUnsafe(otherValue) => [[FixedNumber]]  @SRC<bignumber/fixednumber>
+Returns a new FixedNumber with the value of //fixedvalue// **-** //otherValue//.
 
-_property: fixednumber.mulUnsafe(otherValue) => [[fixednumber]]  @SRC<bignumber/fixednumber>
+_property: fixednumber.mulUnsafe(otherValue) => [[FixedNumber]]  @SRC<bignumber/fixednumber>
 Returns a new FixedNumber with the value of //fixedvalue// **&times;** //otherValue//.
 
-_property: fixednumber.divUnsafe(otherValue) => [[fixednumber]]  @SRC<bignumber/fixednumber>
-Returns a new FixedNumber with the value of //fixedvalue// **&#247;** //otherValue//.
+_property: fixednumber.divUnsafe(otherValue) => [[FixedNumber]]  @SRC<bignumber/fixednumber>
+Returns a new FixedNumber with the value of //fixedvalue// **&div;** //otherValue//.
 
-_property: fixednumber.round([ decimals = 0 ]) => [[fixednumber]]  @SRC<bignumber/fixednumber>
+_property: fixednumber.round([ decimals = 0 ]) => [[FixedNumber]]  @SRC<bignumber/fixednumber>
 Returns a new FixedNumber with the value of //fixedvalue// rounded to //decimals//.
 
 
 _heading: Conversion
 
-_property: fixednumber.toFormat(format) => [[fixednumber]]  @SRC<bignumber/fixednumber>
+_property: fixednumber.toFormat(format) => [[FixedNumber]]  @SRC<bignumber/fixednumber>
 Returns a new FixedNumber with the value of //fixedvalue// with //format//.
 
 _property: fixednumber.toHexString() => string  @SRC<bignumber/fixednumber>
-Returns a [Hexstring](hexstring) representation of //fixednumber//.
+Returns a [[HexString]] representation of //fixednumber//.
 
 _property: fixednumber.toString() => string  @SRC<bignumber/fixednumber>
 Returns a string representation of //fixednumber//.
@@ -117,3 +70,57 @@ _heading: Inspection
 _property: FixedNumber.isFixedNumber(value) => boolean  @SRC<bignumber/fixednumber>
 Returns true if and only if //value// is a **FixedNumber**.
 
+
+_subsection: FixedFormat @<FixedFormat>
+
+A **FixedFormat** is a simple object which represents a decimal
+(base-10) Fixed-Point data representation. Usually using this
+class directly is uneccessary, as passing in a [[FixedFormat--strings]]
+directly into the [[FixedNumber]] will automatically create this.
+
+_heading: Format Strings  @<FixedFormat--strings>
+
+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 [[FixedFormat--strings]]
+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
+The signed-ness of //fixedFormat//, true if negative values are supported.
+
+_property: fixedFormat.width => number
+The width (in bits) of //fixedFormat//.
+
+_property: fixedFormat.decimals => number
+The number of decimal points of //fixedFormat//.
+
+_property: fixedFormat.name => string
+The name of the //fixedFormat//, which can be used to recreate the format
+and is the string that the Solidity language uses to represent this format.
+
+_definition: **//"fixed"//**
+A shorthand for ``fixed128x80``.
+

docs.wrm/api/utils/hashing.wrm

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

docs.wrm/api/utils/hdnode.wrm

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

docs.wrm/api/utils/index.wrm

@@ -1,17 +1,23 @@
-_title: Utilities
-
 _section: Utilities
 
 These utilities are used extensively within the library, but
 are also quite useful for application developers.
 
 _toc:
-    address
     abi
+    address
     bignumber
     bytes
     constants
     display-logic
+    encoding
     fixednumber
     hashing
+    hdnode
+    logger
+    properties
+    signing-key
     strings
+    transactions
+    web
+    wordlists

docs.wrm/api/utils/logger.wrm

@@ -0,0 +1,208 @@
+_section: Logging @<logging>
+
+These are just a few simple logging utilities provided to simplify
+and standardize the error facilities across the Ethers library.
+
+The [[Logger]] library has zero dependencies and is intentionally
+very light so it can be easily included in each library.
+
+The [Censorship](Logger--censorship) functionality relies on one instance
+of the Ethers library being included. In large bundled packages or when
+``npm link`` is used, this may not be the case. If you require this
+functionality, ensure that your bundling is configured properly.
+
+
+_subsection: Logger @<Logger> @SRC<logger:class.Logger>
+
+_property: new ethers.utils.Logger(version) @SRC<logger:constructor.Logger>
+Create a new logger which will include //version// in all errors thrown.
+
+_property: Logger.globalLogger() => [[Logger]] @SRC<logger>
+Returns the singleton global logger.
+
+
+_heading: Logging Output
+
+_property: logger.debug(...args) => void @SRC<logger>
+Log debugging information.
+
+_property: logger.info(...args) => void @SRC<logger>
+Log generic information.
+
+_property: logger.warn(...args) => void @SRC<logger>
+Log warnings.
+
+
+_heading: Errors
+
+These functions honor the current [Censorship](Logger--censorship) and help create
+a standard error model for detecting and processing errors within Ethers.
+
+_property: logger.makeError(message [ , code = UNKNOWN_ERROR [ , params ] ]) => Error @SRC<logger>
+Create an Error object with //message// and an optional //code// and
+additional //params// set. This is useful when an error is needed to be
+rejected instead of thrown.
+
+_property: logger.throwError(message [ , code = UNKNOWN_ERROR [ , params ] ]) => never @SRC<logger>
+Throw an Error with //message// and an optional //code// and
+additional //params// set.
+
+_property: logger.throwArgumentError(message, name, value) => never @SRC<logger>
+Throw an [INVALID_ARGUMENT](errors-InvalidArgument) Error with //name// and //value//.
+
+
+_heading: Usage Validation
+
+There can be used to ensure various properties and actions are safe.
+
+_property: logger.checkAbstract(target, kind) => void @SRC<logger>
+Checks that //target// is not //kind// and performs the same operatons
+as ``checkNew``. This is useful for ensuring abstract classes are not
+being instantiated.
+
+_property: logger.checkArgumentCount(count, expectedCound [ , message) => void @SRC<logger>
+If //count// is not equal to //expectedCount//, throws a [MISSING_ARGUMENT](errors-MissingArgument)
+or [UNEXPECTED_ARGUMENT](errors-UnexpectedArgument) error.
+
+_property: logger.checkNew(target, kind) => void @SRC<logger>
+If //target// is not a valid ``this`` or ``target`` value, throw a
+[MISSING_NEW](errors-MissingNew) error. This is useful to ensure
+callers of a Class are using ``new``.
+
+_property: logger.checkNormalize(message) => void @SRC<logger>
+Check that the environment has a correctly functioning [[link-js-normalize]]. If not, a
+[UNSUPPORTED_OPERATION](errors-UnsupportedOperation) error is thrown.
+
+_property: logger.checkSafeUint53(value [, message ]) => void @SRC<logger>
+If //value// is not safe as a [JavaScript number](link-wiki-ieee754), throws a
+[NUMERIC_FAULT](errors-NumericFault) error.
+
+
+_heading: Censorship @<Logger--censorship>
+
+_property: Logger.setCensorship(censor [ , permanent = false ]) => void @SRC<logger>
+Set error censorship, optionally preventing errors from being uncensored.
+
+In production applications, this prevents any error from leaking information
+by masking the message and values of errors.
+
+This can impact debugging, making it substantially more difficult.
+
+_property: Logger.setLogLevel(logLevel) => void @SRC<logger>
+Set the log level, to suppress logging output below a [particular log level](Logger-levels).
+
+
+_subsection: Errors @<errors>
+
+Every error in Ethers has a ``code`` value, which is a string that will
+match one of the following error codes.
+
+
+_heading: Generic Error Codes
+
+_property: Logger.errors.NOT_IMPLEMENTED
+The operation is not implemented.
+
+_property: Logger.errors.SERVER_ERROR
+There was an error communicating with a server.
+
+_property: Logger.errors.TIMEOUT @<errors-Timeout>
+A timeout occurred.
+
+_property: Logger.errors.UNKNOWN_ERROR @<errors-UnknownError>
+A generic unknown error.
+
+_property: Logger.errors.UNSUPPORTED_OPERATION @<errors-UnsupportedOperation>
+The operation is not supported.
+
+
+_heading: Safety Error Codes
+
+_property: Logger.errors.BUFFER_OVERRUN
+The amount of data needed is more than the amount of data required,
+which would cause the data buffer to read past its end.
+
+_property: Logger.errors.NUMERIC_FAULT @<errors-NumericFault>
+There was an invalid operation done on numeric values.
+
+Common cases of this occur when there is [[link-wiki-overflow]],
+[[link-wiki-underflow]] in fixed numeric types or division by zero.
+
+
+_heading: Usage Error Codes
+
+_property: Logger.errors.INVALID_ARGUMENT @<errors-InvalidArgument>
+The type or value of an argument is invalid. This will generally also
+include the ``name`` and ``value`` of the argument. Any function which
+accepts sensitive data (such as a private key) will include the string
+``[\[REDACTED]\]`` instead of the value passed in.
+
+_property: Logger.errors.MISSING_ARGUMENT @<errors-MissingArgument>
+An expected parameter was not specified.
+
+_property: Logger.errors.MISSING_NEW @<errors-MissingNew>
+An object is a Class, but is now being called with ``new``.
+
+_property: Logger.errors.UNEXPECTED_ARGUMENT @<errors-UnexpectedArgument>
+Too many parameters we passed into a function.
+
+
+_heading: Ethereum Error Codes
+
+_property: Logger.errors.CALL_EXCEPTION
+An attempt to call a blockchain contract (getter) resulted in a
+revert or other error.
+
+_property: Logger.errors.INSUFFICIENT_FUNDS
+The account is attempting to make a transaction which costs more than is
+available.
+
+A sending account must have enough ether to pay for the value, the gas limit
+(at the gas price) as well as the intrinsic cost of data. The intrinsic cost
+of data is 4 gas for each zero byte and 68 gas for each non-zero byte.
+
+_property: Logger.errors.NETWORK_ERROR
+An Ethereum network validation error, such as an invalid chain ID.
+
+_property: Logger.errors.NONCE_EXPIRED
+The nonce being specified has already been used in a mined transaction.
+
+_property: Logger.errors.REPLACEMENT_UNDERPRICED
+When replacing a transaction, by using a nonce which has already been sent to
+the network, but which has not been mined yet the new transaction must specify
+a higher gas price.
+
+This error occurs when the gas price is insufficient to //bribe// the transaction
+pool to prefer the new transaction over the old one. Generally, the new gas price
+should be about 50% + 1 wei more, so if a gas price of 10 gwei was used, the
+replacement should be 15.000000001 gwei.
+
+_property: Logger.errors.UNPREDICTABLE_GAS_LIMIT
+When estimating the required amount of gas for a transaction, a node is queried for
+its best guess.
+
+If a node is unable (or unwilling) to predict the cost, this error occurs.
+
+The best remedy for this situation is to specify a gas limit in the transaction
+manually.
+
+This error can also indicate that the transaction is expected to fail regardless,
+if for example an account with no tokens is attempting to send a token.
+
+
+_subsection: Log Levels @<Logger-levels>
+
+_property: Logger.levels.DEBUG
+Log all output, including debugging information.
+
+_property: Logger.levels.INFO
+Only log output for infomational, warnings and errors.
+
+_property: Logger.levels.WARNING
+Only log output for warnings and errors.
+
+_property: Logger.levels.ERROR
+Only log output for errors.
+
+_property: Logger.levels.OFF
+Do not output any logs.

docs.wrm/api/utils/properties.wrm

@@ -0,0 +1,9 @@
+_section: Property Utilities
+
+_property: ethers.utils.checkProperties() => void
+
+_property: ethers.utils.deepCopy(anObject) => any
+_property: ethers.utils.defineReadOnly(anObject, name, value) => void
+_property: ethers.utils.getStatic(aConstructor, key) => any
+_property: ethers.utils.resolveProperties(anObject) => Promise<any> @<utils-resolveproperties> @SRC<properties>
+_property: ethers.utils.shallowCopy(anObject) => any

docs.wrm/api/utils/signing-key.wrm

@@ -1,12 +1,47 @@
-_title: Signing Keys
+_section: Signing Key @<SigningKey>
 
-_section: Signing Key
+_property: new ethers.utils.SigningKey(privateKey)  @<SigningKey-constructor> @src<signing-key:constructor.SigningKey>
+Create a new SigningKey for //privateKey//.
+
+_property: signingKey.privateKey => string<[[DataHexString]]<32>>
+The private key for this Signing Key.
+
+_property: signingKey.publicKey => string<[[DataHexString]]<65>>
+The uncompressed public key for this Signing Key. It will always be
+65 bytes (130 nibbles) and begine with ``0x04``.
+
+_property: signingKey.compressedPublicKey => string<[[DataHexString]]<33>>
+The compressed public key for this Signing Key. It will always be
+33 bytes (66 nibbles) and begine with either ``0x02`` or ``0x03``.
+
+_property: signingKey.signDigest(digest) => [[Signature]]
+Sign the //digest// and return the signature.
+
+_property: signingKey.computeSharedSecret(otherKey) => string<[[DataHexString]]<32>>  @SRC<signing-key>
+Compute the ECDH shared secret with //otherKey//. The //otherKey// may be
+either a public key or a private key, but generally will be a public key from
+another party.
+
+It is best practice that each party computes the hash of this before using it
+as a symmetric key.
+
+_property: SigningKey.isSigningKey(anObject) => boolean  @SRC<signing-key>
+Returns true if //anObject// is a SigningKey.
 
 
-_property: ethers.utils.verifyMessage(message, signature) => string<[[address]]>  @<utils-verifymessage> @SRC<wallet>
+_subsection: Other Functions
+
+_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))
+the v to encode additional data (such as [EIP-155](link-eip-155))
 to be used since the v parameter is still completely non-ambiguous.
+
+_property: ethers.utils.recoverPublicKey(digest, signature) => string<[[DataHexString]]<65>> @<utils-recoverPublicKey>
+
+_property: ethers.utils.computePublicKey(key [, compressed = false ]) => string<[[DataHexString]]> @<utils-computePublicKey>
+Computes the public key of //key//, optionally compressing it. The //key//
+can be any form of public key (compressed or uncompressed) or a private
+key.

docs.wrm/api/utils/strings.wrm

@@ -1,11 +1,9 @@
-_title: Strings
-
-_section: Strings
+_section: Strings  @<strings>
 
 Tra la la
 
 
-_subsection: Bytes32String @<bytes32-string>
+_subsection: Bytes32String @<Bytes32String>
 
 A string in Solidity is length prefixed with its 256-bit (32 byte)
 length, which means that even short strings require 2 words (64 bytes)
@@ -21,23 +19,23 @@ _note: Note
 Strings that are 31 __//bytes//__ long may contain fewer than 31 __//characters//__,
 since UTF-8 requires multiple bytes to encode international characters.
 
-_property: utils.parseBytes32String(aBytesLike) => string  @<utils-parsebytes32> @SRC<strings>
+_property: ethers.utils.parseBytes32String(aBytesLike) => string  @<utils-parseBytes32> @SRC<strings>
 Returns the decoded string represented by the ``Bytes32`` encoded data.
 
-_property: utils.formatBytes32String(text) => string<[[datahexstring]]<32>>  @<utils-formatbytes32> @SRC<strings>
+_property: ethers.utils.formatBytes32String(text) => string<[[DataHexString]]<32>>  @<utils-formatBytes32> @SRC<strings>
 Returns a ``bytes32`` string representation of //text//. If the
 length of //text// exceeds 31 bytes, it will throw an error.
 
 
-_subsection: UTF-8 Strings @<utf8-string>
+_subsection: UTF-8 Strings @<strings-utf8>
 
-_property: utils.toUtf8Bytes(text [ , form = current ] ) => Uint8Array  @<utils-toutf8bytes> @SRC<strings>
+_property: ethers.utils.toUtf8Bytes(text [ , form = current ] ) => Uint8Array  @<utils-toUtf8Bytes> @SRC<strings>
 Returns the UTF-8 bytes of //text//, optionally normalizing it using the
-[[unicode-normalization-form]] //form//.
+[[strings--unicode-normalization-form]] //form//.
 
-_property: 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//.
+_property: ethers.utils.toUtf8CodePoints(text [ , form = current ] ) => Array<number>  @<utils-toUtf8CodePoints> @SRC<strings>
+Returns the Array of codepoints of //text//, optionally normalized using the
+[[strings--unicode-normalization-form]] //form//.
 
 _note: Note
 This function correctly splits each **user-perceived character** into
@@ -45,28 +43,29 @@ 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  @<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.
+_property: ethers.utils.toUtf8String(aBytesLike [ , onError = error ] ) => string  @<utils-toUtf8String> @SRC<strings>
+Returns the string represented by the UTF-8 bytes of //aBytesLike//.
 
+The //onError// is a [Custom UTF-8 Error function](strings--error-handling) and if not specified
+it defaults to the [error](strings--Utf8Error) function, which throws an error
+on **any** UTF-8 error.
 
-_heading: UnicodeNormalizationForm @<unicode-normalization-form> @SRC<strings/utf8:enum.UnicodeNormalizationForm>
+_subsection: UnicodeNormalizationForm @<strings--unicode-normalization-form> @SRC<strings/utf8:enum.UnicodeNormalizationForm>
 
-There are several [commonly used forms](https://en.wikipedia.org/wiki/Unicode_equivalence)
+There are several [commonly used forms](link-wiki-unicode-equivalence)
 when normalizing UTF-8 data, which allow strings to be compared or hashed in a stable
 way.
 
-_property: utils.UnicodeNormalizationForm.current
+_property: ethers.utils.UnicodeNormalizationForm.current
 Maintain the current normalization form.
 
-_property: utils.UnicodeNormalizationForm.NFC
+_property: ethers.utils.UnicodeNormalizationForm.NFC
 The Composed Normalization Form. This form uses single codepoints
 which represent the fully composed character.
 
 For example, the **&eacute;** is a single codepoint, ``0x00e9``.
 
-_property: utils.UnicodeNormalizationForm.NFD
+_property: ethers.utils.UnicodeNormalizationForm.NFD
 The Decomposed Normalization Form. This form uses multiple codepoints
 (when necessary) to compose a character.
 
@@ -75,7 +74,7 @@ is made up of two codepoints, ``"0x0065"`` (which is the letter ``"e"``)
 and ``"0x0301"`` which is a special diacritic UTF-8 codepoint which
 indicates the previous character should have an acute accent.
 
-_property: utils.UnicodeNormalizationForm.NFKC
+_property: ethers.utils.UnicodeNormalizationForm.NFKC
 The Composed Normalization Form with Canonical Equivalence. The Canonical
 representation folds characters which have the same syntactic representation
 but different semantic meaning.
@@ -83,11 +82,103 @@ but different semantic meaning.
 For example, the Roman Numeral **I**, which has a UTF-8
 codepoint ``"0x2160"``, is folded into the capital letter I, ``"0x0049"``.
 
-_property: utils.UnicodeNormalizationForm.NFKD
+_property: ethers.utils.UnicodeNormalizationForm.NFKD
 The Decomposed Normalization Form with Canonical Equivalence.
 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
-[homoglyph attacks](https://en.wikipedia.org/wiki/IDN_homograph_attack).
+[homoglyph attacks](link-wiki-homoglyph).
+
+
+_subsection: Custom UTF-8 Error Handling @<strings--error-handling>
+
+When converting a string to its codepoints, there is the possibility
+of invalid byte sequences. Since certain situations may need specific
+ways to handle UTF-8 errors, a custom error handling function can be used,
+which has the signature:
+
+_property: errorFunction(reason, offset, bytes, output [ , badCodepoint ]) => number
+The //reason// is one of the [UTF-8 Error Reasons](strings--error-reasons), //offset// is the index
+into //bytes// where the error was first encountered, output is the list
+of codepoints already processed (and may be modified) and in certain Error
+Reasons, the //badCodepoint// indicates the currently computed codepoint,
+but which would be rejected because its value is invalid.
+
+This function should return the number of bytes to skip past keeping in
+mind the value at //offset// will already be consumed.
+
+
+_heading: UTF-8 Error Reasons @<strings--error-reasons> @SRC<strings/utf8:Utf8ErrorReason>
+
+_property: ethers.utils.Utf8ErrorReason.BAD_PREFIX
+A byte was encountered which is invalid to begin a UTF-8 byte
+sequence with.
+
+_property: ethers.utils.Utf8ErrorReason.MISSING_CONTINUE
+A UTF-8 sequence was begun, but did not have enough continuation
+bytes for the sequence. For this error the //ofset// is the index
+at which a continuation byte was expected.
+
+_property: ethers.utils.Utf8ErrorReason.OUT_OF_RANGE
+The computed codepoint is outside the range for valid UTF-8
+codepoints (i.e. the codepoint is greater than 0x10ffff).
+This reason will pass the computed //badCountpoint// into
+the custom error function.
+
+_property: ethers.utils.Utf8ErrorReason.OVERLONG
+Due to the way UTF-8 allows variable length byte sequences
+to be used, it is possible to have multiple representations
+of the same character, which means
+[overlong sequences](link-wiki-utf8-overlong)
+allow for a non-distinguished string to be formed, which can
+impact security as multiple strings that are otherwise
+equal can have different hashes.
+
+Generally, overlong sequences are an attempt to circumvent
+some part of security, but in rare cases may be produced by
+lazy libraries or used to encode the null terminating
+character in a way that is safe to include in a ``char*``.
+
+This reason will pass the computed //badCountpoint// into the
+custom error function, which is actually a valid codepoint, just
+one that was arrived at through unsafe methods.
+
+_property: ethers.utils.Utf8ErrorReason.OVERRUN
+The string does not have enough characters remaining for the
+length of this sequence.
+
+_property: ethers.utils.Utf8ErrorReason.UNEXPECTED_CONTINUE
+This error is similar to BAD_PREFIX, since a continuation byte
+cannot begin a valid sequence, but many may wish to process this
+differently. However, most developers would want to trap this
+and perform the same operation as a BAD_PREFIX.
+
+_property: ethers.utils.Utf8ErrorReason.UTF16_SURROGATE
+The computed codepoint represents a value reserved for
+UTF-16 surrogate pairs.
+This reason will pass the computed surrogate half
+//badCountpoint// into the custom error function.
+
+
+
+_heading: Provided UTF-8 Error Handling Functions
+
+There are already several functions available for the  most common
+situations.
+
+_property: ethers.utils.Utf8ErrorFuncs.error @<strings--Utf8Error> @SRC<strings/utf8:errorFunc>
+The will throw an error on **any** error with a UTF-8 sequence, including
+invalid prefix bytes, overlong sequences, UTF-16 surrogate pairs.
+
+_property: ethers.utils.Utf8ErrorFuncs.ignore @<strings--Utf8Ignore> @SRC<strings/utf8:ignoreFunc>
+This will drop all invalid sequences (by consuming invalid prefix bytes and
+any following continuation bytes) from the final string as well as permit
+overlong sequences to be converted to their equivalent string.
+
+_property: ethers.utils.Utf8ErrorFuncs.replace @<strings--Utf8Replace> @SRC<strings/utf8:replaceFunc>
+This will replace all invalid sequences (by consuming invalid prefix bytes and
+any following continuation bytes) with the
+[UTF-8 Replacement Character](link-wiki-utf8-replacement),
+(i.e. U+FFFD).

docs.wrm/api/utils/transactions.wrm

@@ -0,0 +1,118 @@
+_section: Transactions @<transactions>
+
+_subsection: Types
+
+_heading: UnsignedTransaction @<UnsignedTransaction>
+An unsigned transaction represents a transaction that has not been
+signed and its values are flexible as long as they are not ambiguous.
+
+_property: unsignedTransaction.to => string<[Address](address)>
+The addres this transaction is to.
+
+_property: unsignedTransaction.nonce => number
+The nonce of this transaction.
+
+_property: unsignedTransaction.gasLimit => [[BigNumberish]]
+The gas limit for this transaction.
+
+_property: unsignedTransaction.gasPrice => [[BigNumberish]]
+The gas price for this transaction.
+
+_property: unsignedTransaction.data => [[BytesLike]]
+The data for this transaction.
+
+_property: unsignedTransaction.value => [[BigNumberish]]
+The value (in wei) for this transaction.
+
+_property: unsignedTransaction.chainId => number
+The chain ID for this transaction. If the chain ID is 0 or null,
+then [[link-eip-155]] is disabled and legacy signing is
+used, unless overridden in a signature.
+
+
+_heading: Transaction @<Transaction>
+A generic object to represent a transaction.
+
+_property: transaction.hash => string<[[DataHexString]]<32>>
+The transaction hash, which can be used as an identifier for
+//transaction//. This is the keccak256 of the serialized RLP encoded
+representation of //transaction//.
+
+_property: unsignedTransaction.to => string<[Address](address)>
+The address //transaction// is to.
+
+_property: transaction.from => string<[Address](address)>
+The address //transaction// is from.
+
+_property: transaction.nonce => number
+The nonce for //transaction//. Each transaction sent to the network
+from an account includes this, which ensures the order and
+non-replayability of a transaction. This must be equal to the current
+number of transactions ever sent to the network by the **from** address.
+
+_property: transaction.gasLimit => [[BigNumber]]
+The gas limit for //transaction//. An account must have enough ether to
+cover the gas (at the specified **gasPrice**). Any unused gas is
+refunded at the end of the transaction, and if there is insufficient gas
+to complete execution, the effects of the trasaction are reverted, but
+the gas is **fully consumed** and an out-of-gas error occurs.
+
+_property: transaction.gasPrice => [[BigNumber]]
+The price (in wei) per unit of gas for //transaction//.
+
+_property: transaction.data => [[BytesLike]]
+The data for //transaction//. In a contract this is the call data.
+
+_property: transaction.value => [[BigNumber]]
+The value (in wei) for //transaction//.
+
+_property: transaction.chainId => number
+The chain ID for //transaction//. This is used as part of
+[[link-eip-155]] to prevent replay attacks on different
+networks.
+
+For example, if a transaction was made on ropsten with an account
+also used on homestead, it would be possible for a transaction
+signed on ropsten to be executed on homestead, which is likely
+unintended.
+
+There are situations where replay may be desired, however these
+are very rare and it is almost always recommended to specify the
+chain ID.
+
+_property: transaction.r => string<[[DataHexString]]<32>>
+The r portion of the elliptic curve signatures for //transaction//.
+This is more accurately, the x coordinate of the point r (from
+which the y can be computed, along with v).
+
+_property: transaction.s => string<[[DataHexString]]<32>>
+The s portion of the elliptic curve signatures for //transaction//.
+
+_property: transaction.v => number
+The v portion of the elliptic curve signatures for //transaction//.
+This is used to refine which of the two possible points a given
+x-coordinate can have, and in [[link-eip-155]] is additionally
+used to encode the chain ID into the serialized transaction.
+
+
+_subsection: Functions
+
+_property: ethers.utils.parseTransaction(aBytesLike) => [[Transaction]]  @<utils-parseTransaction> @SRC<transactions:parse>
+Parses the transaction properties from a serialized transactions.
+
+_property: ethers.utils.serializeTransaction(tx [ , signature ]) => string<[[DataHexString]]>  @<utils-serializeTransaction> @SRC<transactions:serialize>
+Computes the serialized //transaction//, optionally serialized with
+the a //signature//. If //signature// is not present, the unsigned
+serialized transaction is returned, which can be used to compute the
+hash necessary to sign.
+
+This function uses [[link-eip-155]] if a chainId is provided,
+otherwise legacy serialization is used. It is **highly** recommended
+to always specify a //chainId//.
+
+If //signature// includes a chain ID (explicitly or implicitly by using an
+[[link-eip-155]] ``v`` or ``_vs``) it will be used to compute the
+chain ID.
+
+If there is a mismatch between the chain ID of //transaction// and //signature//
+an error is thrown.

docs.wrm/api/utils/web.wrm

@@ -0,0 +1,69 @@
+_section: Web Utilities  @<web>
+
+
+_property: ethers.utils.fetchJson(urlOrConnectionInfo [, json [ , processFunc ] ]) => Promise<any> @<utils-fetchJson>
+Fetch and parse the JSON content from //urlOrConnectionInfo//, with the
+optiona body //json// and optionally processing the result with //processFun//
+before returning it.
+
+_property: ethers.utils.poll(pollFunc [, options ]) => Promise<any> @<utils-poll>
+Repeatedly call pollFunc using the [[PollOptions]] until it returns a
+value other than undefined.
+
+
+_heading: ConnectionInfo @<ConnectionInfo>
+
+_property: connection.url => string
+The URL to connect to.
+
+_property: connection.user => string
+The username to use for [[link-wiki-basicauth]].
+The default is null (i.e. do not use basic authentication)
+
+_property: connection.password => string
+The password to use for [[link-wiki-basicauth]].
+The default is null (i.e. do not use basic authentication)
+
+_property: connection.allowInsecureAuthentication => boolean
+Allow [[link-wiki-basicauth]] over non-secure HTTP. The default is false.
+
+_property: connection.timeout => number
+How long to wait before rejecting with a //timeout// error.
+
+_property: connection.headers => { [ key: string]: string }
+Additional headers to include in the connection.
+
+
+_heading: PollOptions @<PollOptions>
+
+_property: options.timeout => number
+The amount of time allowed to ellapse before triggering a timeout
+error.
+
+_property: options.floor => number
+The minimum time limit to allow for [[link-wiki-backoff]].
+
+The default is 0s.
+
+_property: options.ceiling => number
+The maximum time limit to allow for [[link-wiki-backoff]].
+
+The default is 10s.
+
+_property: options.interval => number
+The interval used during [[link-wiki-backoff]] calculation.
+
+The default is 250ms.
+
+_property: options.retryLimit => number
+The number of times to retry in the event of an error or //undefined// is
+returned.
+
+_property: options.onceBlock => [[Provider]]
+If this is specified, the polling will wait on new blocks from
+//provider// before attempting the //pollFunc// again.
+
+_property: options.oncePoll => [[Provider]]
+If this is specified, the polling will occur on each poll
+cycle of //provider// before attempting the //pollFunc//
+again.

docs.wrm/api/utils/wordlists.wrm

@@ -0,0 +1,58 @@
+_section: Wordlists @<wordlists>
+
+_subsection: Wordlist @<Wordlist>
+
+_property: wordlist.locale => string
+The locale for this wordlist.
+
+_property: wordlist.getWord(index) => string
+Returns the word at //index//.
+
+_property: wordlist.getWordIndex(word) => number
+Returns the index of //word// within the wordlist.
+
+_property: wordlist.split(mnemonic) => Array<string>
+Returns the mnemonic split into each individual word, according to a
+locale's valid whitespace character set.
+
+_property: wordlist.join(words) => string
+Returns the mnemonic by joining //words// together using the
+whitespace that is standard for the locale.
+
+_property: Wordlist.check(wordlists) => string<[[DataHexString]]<32>>
+Checks that all words map both directions correctly and return the
+hash of the lists. Sub-classes should use this to validate the wordlist
+is correct against the official wordlist hash.
+
+_property: Wordlist.register(wordlist [ , name ]) => void
+Register a wordlist with the list of wordlists, optionally overriding
+the registered //name//.
+
+_subsection: Languages @<wordlists--languages>
+
+_property: ethers.wordlists.cz => Wordlist
+The Czech [[Wordlist]].
+
+_property: ethers.wordlists.en => Wordlist
+The English [[Wordlist]].
+
+_property: ethers.wordlists.es => Wordlist
+The Spanish [[Wordlist]].
+
+_property: ethers.wordlists.fr => Wordlist
+The French [[Wordlist]].
+
+_property: ethers.wordlists.it => Wordlist
+The Italian [[Wordlist]].
+
+_property: ethers.wordlists.ja => Wordlist
+The Japanese [[Wordlist]].
+
+_property: ethers.wordlists.ko => Wordlist
+The Korean [[Wordlist]].
+
+_property: ethers.wordlists.zh_cn => Wordlist
+The Simplified Chinese [[Wordlist]].
+
+_property: ethers.wordlists.zh_tw => Wordlist
+The Traditional Chinese [[Wordlist]].

docs.wrm/cli/asm.wrm

@@ -0,0 +1,220 @@
+_section: Assembler @<cli-asm>
+
+The assembler Command-Line utility allows you to assemble the
+[Ethers ASM Dialect](asm-dialect) into deployable EVM bytecode
+and disassemle EVM bytecode into human-readable mnemonics.
+
+
+_subsection: Help
+
+_code: @lang<text>
+
+Usage:
+   ethers-asm [ FILENAME ] [ OPTIONS ]
+
+OPTIONS
+  --define KEY=VALUE          provide assembler defines
+  --disassemble               Disassemble input bytecode
+  --ignore-warnings           Ignore warnings
+  --pic                       generate position independent code
+  --target LABEL              output LABEL bytecode (default: _)
+
+OTHER OPTIONS
+  --debug                     Show stack traces for errors
+  --help                      Show this usage and exit
+  --version                   Show this version and exit
+
+
+_subsection: Example Input Files
+
+_code: SimpleStore.asm  @lang<asm>
+
+; SimpleStore (uint)
+
+; Set the inital value of 42
+sstore(0, 42)
+
+; Init code to deploy myContract
+codecopy(0, $myContract, #myContract)
+return(0, #myContract)
+
+@myContract {
+    ; Non-payable
+    jumpi($error, callvalue)
+
+    ; Get the Sighash
+    shr({{= 256 - 32 }}, calldataload(0))
+
+    ; getValue()
+    dup1
+    {{= sighash("getValue()") }}
+    jumpi($getValue, eq)
+
+    ; setValue(uint)
+    dup1
+    {{= sighash("setValue(uint)") }}
+    jumpi($setValue, eq)
+
+    ; No matching signature
+    @error:
+        revert(0, 0)
+
+    @getValue:
+        mstore(0, sload(0))
+        return (0, 32)
+
+    @setValue:
+        ; Make sure we have exactly a uint
+        jumpi($error, iszero(eq(calldatasize, 36)))
+
+        ; Store the value
+        sstore(0, calldataload(4))
+        return (0, 0)
+
+    ; There is no *need* for the PUSH32, it just makes
+    ; decompiled code look nicer
+    @checksum[
+        {{= (defines.checksum ? concat([
+                Opcode.from("PUSH32"),
+                id(myContract.source)
+            ]): "0x")
+        }}
+    ]
+}
+
+
+_code: SimpleStore.bin  @lang<text>
+
+0x602a6000556044601160003960446000f334601e5760003560e01c8063209652
+0x5514602457806355241077146030575b60006000fd5b60005460005260206000
+0xf35b6024361415601e5760043560005560006000f3
+
+
+_note: Note: Bytecode File Syntax
+A bin file may be made up of multiple blocks of bytecode, each may
+optionally begin with a ``0x`` prefix, all of which **must** be of
+even length (since bytes are required, with 2 nibbles per byte)
+
+All whitespace is ignored.
+
+_subsection: Assembler Examples
+
+The assembler converts an [Ethers ASM Dialect](asm-dialect) into
+bytecode by running multiple passes of an assemble stage, each pass
+more closely approximating the final result.
+
+This allows small portions of the bytecode to be massaged and tweaked
+until the bytecode stablizes. This allows for more compact jump
+destinations and for code to be include more advanced meta-programming
+techniques.
+
+_code: @lang<shell>
+
+/home/ethers> ethers-asm SimpleStore.asm
+0x602a6000556044601160003960446000f334601e5760003560e01c80632096525514602457806355241077146030575b60006000fd5b60005460005260206000f35b6024361415601e5760043560005560006000f3
+
+# Piping in ASM source code
+/home/ethers> cat SimpleStore.asm | ethers-asm
+# Same as above
+
+# Setting a define which the ASM file checks and adds a checksum
+/home/ethers> ethers-asm --define checksum SimpleStore.asm
+0x602a6000556065601160003960656000f334601e5760003560e01c80632096525514602457806355241077146030575b60006000fd5b60005460005260206000f35b6024361415601e5760043560005560006000f37f10358310d664c9aeb4bf4ce7a10a6a03176bd23194c8ccbd3160a6dac90774d6
+
+
+_heading: Options
+
+_definition: **-\-define KEY=VALUE** //or// **-\-define FLAG**
+This allows key/value pairs (where the value is a string) and
+flags (which the value is ``true``) to be passed along to the
+assembler, which can be accessed in
+[Scripting Blocks](asm-dialect-scripting), such as ``{{= defined.someKey }}``.
+
+_definition: **-\-ignore-warnings**
+By default any warning will be treated like an error. This enabled
+by-passing warnings.
+
+_definition: **-\-pic**
+When a program is assembled, the labels are usually given as an
+absolute byte position, which can be jumped to for loops and
+control flow. This means that a program must be installed at a specific
+location.
+
+Byt specifying the **Position Independent Code** flag, code
+will be generated in a way such that all offsets are relative, allowing
+the program to be moved without any impact to its logic.
+
+This does incur an additional gsas cost of 8 gas per offset access though.
+
+_definition: **-\-target LABEL**
+All programs have a root scope named ``_`` which is by default
+assembled. This option allows another labelled target (either a
+[[asm-dialect-scope]] or a [[asm-dialect-datasegment]] to be
+assembled instead. The entire program is still assembled per usual,
+so this only impacts which part of the program is output.
+
+_subsection: Disassembler Examples
+
+A disassembled program shows offsets and mnemonics for the given
+bytecode. This format may change in the future to be more
+human-readable.
+
+_code: @lang<shell>
+
+/home/ethers> ethers-asm --disassemble SimpleStore.bin
+0000 : 0x2a                                                               ; #1
+0002 : 0x00                                                               ; #1
+0004 : SSTORE
+0005 : 0x44                                                               ; #1
+0007 : 0x11                                                               ; #1
+0009 : 0x00                                                               ; #1
+000b : CODECOPY
+000c : 0x44                                                               ; #1
+000e : 0x00                                                               ; #1
+0010 : RETURN
+0011 : CALLVALUE
+0012 : 0x1e                                                               ; #1
+0014 : JUMPI
+0015 : 0x00                                                               ; #1
+0017 : CALLDATALOAD
+0018 : 0xe0                                                               ; #1
+001a : SHR
+001b : DUP1
+001c : 0x20965255                                                         ; #4
+0021 : EQ
+0022 : 0x24                                                               ; #1
+0024 : JUMPI
+0025 : DUP1
+0026 : 0x55241077                                                         ; #4
+002b : EQ
+002c : 0x30                                                               ; #1
+002e : JUMPI
+002f*: JUMPDEST
+0030 : 0x00                                                               ; #1
+0032 : 0x00                                                               ; #1
+0034 : REVERT
+0035*: JUMPDEST
+0036 : 0x00                                                               ; #1
+0038 : SLOAD
+0039 : 0x00                                                               ; #1
+003b : MSTORE
+003c : 0x20                                                               ; #1
+003e : 0x00                                                               ; #1
+0040 : RETURN
+0041*: JUMPDEST
+0042 : 0x24                                                               ; #1
+0044 : CALLDATASIZE
+0045 : EQ
+0046 : ISZERO
+0047 : 0x1e                                                               ; #1
+0049 : JUMPI
+004a : 0x04                                                               ; #1
+004c : CALLDATALOAD
+004d : 0x00                                                               ; #1
+004f : SSTORE
+0050 : 0x00                                                               ; #1
+0052 : 0x00                                                               ; #1
+0054 : RETURN
+
+/home/ethers> cat SimpleStore.bin | ethers-asm --disassemble
+# Same as above

docs.wrm/cli/ens.wrm

@@ -1,12 +1,81 @@
-_title: ENS
-
-_section: ENS
+_section: Ethereum Naming Service @NAV<ENS>
 
 _subsection: Help
 
-_code: ens-help.txt
+_code: @lang<text>
 
-_heading: Examples
+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.
+
+
+_subsection: Examples
 
 TODO examples
 

docs.wrm/cli/ethers-help.txt

@@ -1,65 +0,0 @@
-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.

docs.wrm/cli/ethers-init.txt

@@ -1,14 +0,0 @@
-/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

docs.wrm/cli/ethers-mnemonic-hard.txt

@@ -1,8 +0,0 @@
-/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> 

docs.wrm/cli/ethers-mnemonic.txt

@@ -1,7 +0,0 @@
-/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> 

docs.wrm/cli/ethers-script.txt

@@ -1,19 +0,0 @@
-# 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

docs.wrm/cli/ethers-send.txt

@@ -1,44 +0,0 @@
-# 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
-

docs.wrm/cli/ethers-sign.txt

@@ -1,14 +0,0 @@
-/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

docs.wrm/cli/ethers.wrm

@@ -1,5 +1,3 @@
-_title: Sandbox Utility
-
 _section: Sandbox Utility
 
 The sandbox utility provides a simple way to use the most common
@@ -11,21 +9,157 @@ of the ethers utilities already exposed.
 
 _subsection: Help
 
-_code: ethers-help.txt
+_code: @lang<text>
+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.
 
 _subsection: Examples
 
-_heading: Creating Wallets  @<cliex-init>
+_code: Creating New Wallets @lang<shell> @<cliex-init>
 
-_code: ethers-init.txt
+/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
 
-_heading: Sending Ether and Tokens  @<cliex-send>
 
-_code: ethers-send.txt
+# If you are planning to try out the Ropsten testnet...
+/home/ethers> ethers --network ropsten fund 0x485bcC23ae2E5038ec7ec9b8DCB2A6A6291cC003
+Transaction Hash: 0x8dc55b8f8dc8076acded97f9e3ed7d6162460c0221e2769806006b6d7d1156e0
 
-_heading: Signing Messages  @<cliex-signing>
 
-_code: ethers-sign.txt
+_code: Sending Ether and Tokens  @<cliex-send> @lang<shell>
+
+# 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
+
+
+_code: Signing Messages  @<cliex-signing> @lang<shell>
+
+/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
+
 
 _heading: Scripting  @<cliex-scripting>
 
@@ -33,7 +167,50 @@ 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
+_code: Get the formatted balance of an account  @lang<shell>
+/home/ethers> ethers --network ropsten \
+               --account wallet.json \
+               eval \
+               'accounts[0].getBalance().then(b => formatEther(b))'
+3.141592653589793238
+
+_code: Get the current block number  @lang<shell>
+/home/ethers> ethers --network rinkeby \
+               eval "provider.getBlockNumber()"
+5761009
+
+_code: Convert a Solidity signature to JSON  @lang<shell>
+/home/ethers> ethers eval 'utils.Fragment.from(
+               "function balanceOf(address) view returns (uint)"
+              ).format("json")' | json_pp
+{
+   "inputs" : [
+      {
+         "type" : "address",
+         "name" : "owner"
+      }
+   ],
+   "type" : "function",
+   "payble" : false,
+   "stateMutability" : "view",
+   "ouputs" : [
+      {
+         "type" : "uint256"
+      }
+   ],
+   "name" : "balanceOf",
+   "constant" : true
+}
+
+
+_code: Compute a topic hash  @lang<shell>
+/home/ricmoo> ethers eval 'id("Transfer(address,address,uint256")'
+0xd99659a21de82e379975ce8df556f939a4ccb95e92144f38bb0dd35730ffcdd5
+
+_code: Create a random mnemonic  @lang<shell>
+/home/ricmoo> ethers eval 'Wallet.createRandom().mnemonic'
+useful pond inch knock ritual matrix giggle attend dilemma convince coach amazing
+
 
 _heading: Using Mnemonics (with a password)  @<cliex-mnemonicpassword>
 
@@ -42,17 +219,35 @@ 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
+_code: @lang<shell>
+
+/home/ricmoo> ethers --account mnemonic.txt --mnemonic-password
+Password (mnemonic): ******
+network: homestead (chainId: 1)
+homestead> accounts[0].getAddress()
+<Promise id=0 resolved>
+'0x6d3F723EC1B73141AA4aC248c3ab34A5a1DAD776'
+homestead>
+
 
 _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)
+the password through the [scrypt](link-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
+_code: @lang<shell>
+
+/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>
 
 _warning: Note
 This is still an experimental feature (hence the ``xxx``).

docs.wrm/cli/index.wrm

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

docs.wrm/cli/plugin.txt

@@ -1,10 +0,0 @@
-/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" ]

docs.wrm/cli/plugin.wrm

@@ -1,6 +1,4 @@
-_title: Making Your Own
-
-_section: Making Your Own
+_section: Making Your Own @<cli-diy>
 
 The //cli// library is meant to make it easy to create command
 line utilities of your own.
@@ -56,20 +54,20 @@ make sense.
 Once the prepareArguments is complete (the returned promise is resolved), the ``run``
 is called.
 
-_property: plugin.network => [[provider-network]]
+_property: plugin.network => [[providers-Network]]
 The network this plugin is running for.
 
-_property: plugin.provider => [[provider]]
+_property: plugin.provider => [[Provider]]
 The provider for this plugin is running for.
 
-_property: plugin.accounts => Array<[[signer]]>
+_property: plugin.accounts => Array<[[Signer]]>
 The accounts passed into the plugin using ``--account``,
 ``--account-rpc`` and ``--account-void`` which this plugin can use.
 
-_property: plugin.gasLimit => [[bignumber]]
+_property: plugin.gasLimit => [[BigNumber]]
 The gas limit this plugin should use. This is null if unspecified.
 
-_property: plugin.gasPrice => [[bignumber]]
+_property: plugin.gasPrice => [[BigNumber]]
 The gas price this plugin should use. This is null if unspecified.
 
 _property: plugin.nonce => number
@@ -116,7 +114,20 @@ _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
+_code: @lang<shell>
+
+/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" ]
+
+_null:
 
 Flags are simple binary options (such as the ``--yes``), which are true if present
 otherwise false.

docs.wrm/cli/typescript.wrm

@@ -1,10 +1,27 @@
-_title: TypeScript
-
 _section: TypeScript
 
 _subsection: Help
 
-_code: typescript-help.txt
+_code: @lang<text>
+
+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.
+
 
 _subsection: Examples
 

docs.wrm/concepts/events.wrm

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

docs.wrm/concepts/gas.wrm

@@ -1,5 +1,3 @@
-_title: Gas
-
 _section: Gas @<gas>
 
 Explain attack vectors

docs.wrm/concepts/index.wrm

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

docs.wrm/concepts/security/index.wrm

@@ -0,0 +1,85 @@
+_section: Security
+
+_subsection: Key Derivation Functions @<security-pbkdf>
+
+This is not specific to Ethereum, but is a useful technique
+to understand and has some implications on User Experience.
+
+Many people are concerned that encrypting and decrypting an
+Ethereum wallet is quite slow and can take quite some time.
+It is important to understand this is intentional and provides
+much stronger security.
+
+The algorithm usually used for this process is [scrypt](link-wiki-scrypt),
+which is a memory and CPU intensive algorithm which computes
+a key (fixed-length psudo-random series of bytes) for a given
+password.
+
+
+_heading: Why does it take so long?
+
+The goal is to use as much CPU and memory as possible during
+this algorithm, so that a single computer can only compute a
+very small number of results for some fixed amount of time. To
+scale up an attack, the attacker requires additional compuers,
+increasing the cost to [brute-force attack](link-wiki-bruteforce)
+to guess the password.
+
+For example, if a user knows their correct password, this process
+may take 10 seconds for them to unlock their own wallet and proceed.
+
+But since an attacker does not know the password, they must guess; and
+each guess also requires 10 seconds. So, if they wish to try guessing 1
+million passwords, their computer would be completely tied up for 10
+million seconds, or around 115 days.
+
+Without using an algorithm like this, a user would be able
+to log in instantly, however, 1 million passwords would only
+take a few seconds to attempt. Even secure passwords would
+likely be broken within a short period of time. There is no way
+the algorithm can be faster for a legitimate user without also
+being faster for an attacker.
+
+_heading: Mitigating the User Experience
+
+Rather than reducing the security (see below), a better practice is to make
+the user feel better about waiting. The Ethers encryption and decryption
+API allows the developer to incorporate a progress bar, by passing in a
+progress callback which will be periodically called with a number between
+0 and 1 indication percent completion.
+
+In general a progress bar makes the experience feel faster, as well as
+more comfortable since there is a clear indication how much (relative) time
+is remaining. Additionally, using language like //"decrpyting..."// in
+a progress bar makes a user feel like there time is not being //needlessly//
+wasted.
+
+_heading: Work-Arounds (not recommended)
+
+There are ways to reduce the time required to decrypt an Ethereum JSON
+Wallet, but please keep in mind that doing so **discards nearly all security**
+on that wallet.
+
+The scrypt algorithm is designed to be tuned. The main purpose of this is
+to increase the difficulty as time goes on and computers get faster, but
+it can also be tuned down in situations where the security is less important.
+
+_code: @LANG<javascript>
+
+// Our wallet object
+const wallet = Wallet.createRandom();
+
+// The password to encrypt with
+const password = "password123";
+
+// WARNING: Doing this substantially reduces the security
+//          of the wallet. This is highly NOT recommended.
+
+// We override the default scrypt.N value, which is used
+// to indicate the difficulty to crack this wallet.
+const json = wallet.encrypt(password, {
+  scrypt: {
+    // The number must be a power of 2 (default: 131072)
+    N: 64
+  }
+});

docs.wrm/config.js

@@ -100,12 +100,11 @@ const getSourceUrl = (function(path, include, exclude) {
             if (!def.filename.match(pathCheck)) { return; }
             def.defs.forEach((d) => {
                 if (!d.name.match(match)) { return; }
-                result.push({ filename: def.filename, lineNo: d.lineNo });
+                result.push({ filename: def.filename, lineNo: d.lineNo, name: d.name });
             });
         });
-
         if (result.length > 1) {
-            throw new Error(`Amibguous TypeScript link: ${ key } in [ ${ result.map((r) => JSON.stringify(r.filename + ":" + r.lineNo)).join(", ") }]`);
+            throw new Error(`Ambiguous TypeScript link: ${ key } in [ ${ result.map((r) => JSON.stringify(r.filename + ":" + r.lineNo + "@" + r.name)).join(", ") }]`);
         } else if (result.length === 0) {
             throw new Error(`No matching TypeScript link: ${ key }`);
         }
@@ -116,14 +115,168 @@ const getSourceUrl = (function(path, include, exclude) {
     }
 })("../packages/", new RegExp("packages/.*/src.ts/.*\.ts$"), new RegExp("/node_modules/|src.ts/.*browser.*"));
 
+function codeContextify(context) {
+    const { inspect } = require("util");
+    const ethers = context.require("./packages/ethers");
+
+    context.ethers = ethers;
+    context.BigNumber = ethers.BigNumber;
+    context.constants = ethers.constants;
+    context.utils = ethers.utils;
+    context.arrayify = ethers.utils.arrayify;
+    context.hexlify = ethers.utils.hexlify;
+    context.hexValue = ethers.utils.hexValue;
+    context.Wallet = ethers.Wallet;
+
+    context.BigNumber.prototype[inspect.custom] = function(depth, options) {
+        return `{ BigNumber: ${JSON.stringify(this.toString()) } }`;
+    }
+
+
+    context._inspect = function(value, depth) {
+        /*
+        if (context.BigNumber.isBigNumber(value)) {
+            return `{ BigNumber: ${ JSON.stringify(value.toString()) } }`;
+        }
+
+        if (value && typeof(value.length) === "number" && typeof(value) !== "string") {
+            return "[ " + Array.prototype.map.call(value, (i) => context._inspect(i, (depth || 0) + 1)).join(", ") + " ]";
+        }
+
+        if (typeof(value) === "object" && depth == null) {
+            const keys = Object.keys(value);
+            keys.sort();
+            value = keys.reduce((accum, key) => {
+                accum[key] = value[key];
+                return accum;
+            }, { });
+        */
+            /*
+            return [
+                "{",
+                keys.map((key) => {
+                    return `  ${key}: ${ context._inspect(value[key], 1) },`;
+                }).join("\n"),
+                "}"
+            ].join("\n");
+            */
+        //}
+
+        //return JSON.stringify(value);
+        return inspect(value, {
+            compact: false,
+            sorted: true,
+        });
+    }
+}
+
 module.exports = {
   title: "ethers",
-  foo: "Bat",
   subtitle: "v5.0-beta",
   logo: "logo.svg",
-  link: "https://docs-beta.ethers.io",
+
+  link: "https:/\/docs-beta.ethers.io",
+  copyright: "The content of this site is licensed under the [Creative Commons License](https:/\/choosealicense.com/licenses/cc-by-4.0/). Generated on &$now;.",
+
   markdown: {
       "banner": "-----\n\nDocumentation: [html](https://docs-beta.ethers.io/)\n\n-----\n\n"
   },
-  getSourceUrl: getSourceUrl
+
+  codeContextify: codeContextify,
+
+  getSourceUrl: getSourceUrl,
+
+  codeRoot: "../",
+
+  externalLinks: {
+      "link-alchemy": "https:/\/alchemyapi.io",
+      "link-cloudflare": "https:/\/developers.cloudflare.com/distributed-web/ethereum-gateway/",
+      "link-ethereum": "https:/\/ethereumorg",
+      "link-etherscan": "https:/\/etherscan.io",
+      "link-etherscan-api": "https:/\/etherscan.io/apis",
+      "link-flatworm": "https:/\/github.com/ricmoo/flatworm",
+      "link-geth": { name: "Geth", url: "https:/\/geth.ethereum.org" },
+      "link-infura": { name: "INFURA", url: "https:/\/infura.io" },
+      "link-ledger": "https:/\/www.ledger.com",
+      "link-metamask": { name: "Metamask", url: "https:/\/metamask.io/" },
+      "link-parity": { name: "Parity", url: "https:/\/www.parity.io" },
+      "link-rtd": "https:/\/github.com/readthedocs/sphinx_rtd_theme",
+      "link-semver": { name: "semver", url: "https:/\/semver.org" },
+      "link-solidity": { name: "Solidity" , url: "https:/\/solidity.readthedocs.io/en/v0.6.2/" },
+      "link-sphinx": "https:/\/www.sphinx-doc.org/",
+
+      "link-json-rpc": "https:/\/github.com/ethereum/wiki/wiki/JSON-RPC",
+      "link-parity-trace": "https:/\/openethereum.github.io/wiki/JSONRPC-trace-module",
+      "link-parity-rpc": "https:/\/openethereum.github.io/wiki/JSONRPC",
+      "link-geth-debug": "https:/\/github.com/ethereum/go-ethereum/wiki/Management-APIs#debug",
+      "link-geth-rpc": "https:/\/github.com/ethereum/go-ethereum/wiki/Management-APIs",
+
+      "link-legacy-docs3": "https:/\/docs.ethers.io/ethers.js/v3.0/html/",
+      "link-legacy-docs4": "https:/\/docs.ethers.io/ethers.js",
+
+      "link-infura-secret": "https:/\/infura.io/docs/gettingStarted/authentication",
+
+      "link-web3": "https:/\/github.com/ethereum/web3.js",
+      "link-web3-http": "https:/\/github.com/ethereum/web3.js/tree/1.x/packages/web3-providers-http",
+      "link-web3-ipc": "https:/\/github.com/ethereum/web3.js/tree/1.x/packages/web3-providers-ipc",
+      "link-web3-ws": "https:/\/github.com/ethereum/web3.js/tree/1.x/packages/web3-providers-ws",
+
+      "link-solc-output": "https:/\/solidity.readthedocs.io/en/v0.6.0/using-the-compiler.html#output-description",
+
+      "link-icap": "https:/\/github.com/ethereum/wiki/wiki/Inter-exchange-Client-Address-Protocol-%28ICAP%29",
+      "link-jsonrpc": "https:/\/github.com/ethereum/wiki/wiki/JSON-RPC",
+      "link-mit": "https:/\/en.m.wikipedia.org/wiki/MIT_License",
+      "link-namehash": "https:/\/docs.ens.domains/contract-api-reference/name-processing#hashing-names",
+      "link-rlp": { name: "Recursive Length Prefix", url: "https:/\/github.com/ethereum/wiki/wiki/RLP" },
+
+      "link-ethersio": "https:/\/ethers.io/",
+      "link-ethers-docs": "https:/\/docs.ethers.io/",
+      "link-ethers-js": "https:/\/cdn.ethers.io/lib/ethers-5.0.esm.min.js",
+      "link-ethers-npm": "https:/\/www.npmjs.com/search?q=%40ethersproject%2F",
+      "link-ethers-asm-grammar": "https:/\/github.com/ethers-io/ethers.js/blob/ethers-v5-beta/packages/asm/grammar.jison",
+
+      "link-eip-155": { name: "EIP-155", url: "https:/\/eips.ethereum.org/EIPS/eip-155" },
+      "link-eip-191": { name: "EIP-191", url: "https:/\/eips.ethereum.org/EIPS/eip-191" },
+      "link-eip-609": "https:/\/eips.ethereum.org/EIPS/eip-609",
+      "link-eip-1014": "https:/\/eips.ethereum.org/EIPS/eip-1014",
+      "link-eip-1193": { name: "EIP-1193", url: "https:/\/eips.ethereum.org/EIPS/eip-1193" },
+      "link-eip-2098": "https:/\/eips.ethereum.org/EIPS/eip-2098",
+      "link-bip-39": "https://en.bitcoin.it/wiki/BIP_0039",
+      "link-bip-32": "https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki",
+
+      "link-npm-elliptic": { name: "elliptic", url: "https:/\/www.npmjs.com/package/elliptic" },
+      "link-npm-events": { name: "EventEmitter", url: "https:/\/nodejs.org/dist/latest-v13.x/docs/api/events.html#events_class_eventemitter" },
+      "link-npm-bnjs": { name: "BN.js", url: "https:/\/www.npmjs.com/package/bn.js" },
+      "link-npm-query-bignumber": "https:/\/www.npmjs.com/search?q=bignumber",
+
+      "link-js-array": "https:/\/developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array",
+      "link-js-bigint": "https:/\/developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt",
+      "link-js-normalize": { name: "String.normalize", url: "https:/\/developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize" },
+      "link-js-maxsafe": "https:/\/developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER#Description",
+      "link-js-typedarray": "https:/\/developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray",
+
+      "link-ricmoo-humanreadableabi": "https:/\/blog.ricmoo.com/human-readable-contract-abis-in-ethers-js-141902f4d917",
+
+      "link-wiki-basicauth": { name: "Basic Authentication", url: "https:/\/en.wikipedia.org/wiki/Basic_access_authentication" },
+      "link-wiki-backoff": { name: "Exponential Backoff", url: "https:/\/en.wikipedia.org/wiki/Exponential_backoff" },
+      "link-wiki-bloomfilter": { name: "Bloom Filter", url: "https:/\/en.wikipedia.org/wiki/Bloom_filter" },
+      "link-wiki-bruteforce": "https:/\/en.wikipedia.org/wiki/Brute-force_attack",
+      "link-wiki-cryptographichash": "https:/\/en.wikipedia.org/wiki/Cryptographic_hash_function",
+      "link-wiki-ecrecover": { name: "ECDSA Public Key Recovery", url: "https:/\/en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm#Public_key_recovery" },
+      "link-wiki-homoglyph": "https:/\/en.wikipedia.org/wiki/IDN_homograph_attack",
+      "link-wiki-hmac": "https:/\/en.wikipedia.org/wiki/HMAC",
+      "link-wiki-iban": "https:/\/en.wikipedia.org/wiki/International_Bank_Account_Number",
+      "link-wiki-ieee754": "https:/\/en.wikipedia.org/wiki/Double-precision_floating-point_format",
+      "link-wiki-ripemd": "https:/\/en.m.wikipedia.org/wiki/RIPEMD",
+      "link-wiki-sha2": "https:/\/en.wikipedia.org/wiki/SHA-2",
+      "link-wiki-twoscomplement": "https:/\/en.wikipedia.org/wiki/Two%27s_complement",
+      "link-wiki-unicode-equivalence": "https:/\/en.wikipedia.org/wiki/Unicode_equivalence",
+      "link-wiki-utf8-overlong": "https:/\/en.wikipedia.org/wiki/UTF-8#Overlong_encodings",
+      "link-wiki-utf8-replacement": "https:/\/en.wikipedia.org/wiki/Specials_%28Unicode_block%29#Replacement_character",
+      "link-wiki-scrypt": "https:/\/en.wikipedia.org/wiki/Scrypt",
+      "link-wiki-sha3": "https:/\/en.wikipedia.org/wiki/SHA-3",
+      "link-wiki-shuffle": { name: "Fisher-Yates Shuffle", url: "https:/\/en.wikipedia.org/wiki/Fisher-Yates_shuffle" },
+      "link-wiki-overflow": { name: "overflow", url: "https:/\/en.wikipedia.org/wiki/Integer_overflow" },
+      "link-wiki-underflow": { name: "arithmetic underflow", url: "https:/\/en.wikipedia.org/wiki/Arithmetic_underflow" },
+  }
 };

docs.wrm/contributing.wrm

@@ -1,5 +1,3 @@
-_title: Contributing and Hacking
-
 _section: Contributing and Hacking
 
 The ethers.js library is something that I've written out of necessity,

docs.wrm/cookbook/index.wrm

@@ -1,5 +1,3 @@
-_title: Cookbook
-
 _section: Cookbook
 
 Cooking...

docs.wrm/documentation.wrm

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

docs.wrm/documentation/examples.txt

@@ -1,30 +0,0 @@
-_section: Hello World @<link-to-this-section>
-
-_subsection: Some Example @<link-to-this-subsection>
-
-_heading: Large Bold Text @<link-to-this-heading>
-
-_definition: Flatworm
-A phylum of relatively **simple** bilaterian, unsegmented,
-soft-bodied invertebrates.
-
-_property: String.fromCharCode(code) => string
-Returns a string created from //code//, a sequence of
-UTF-16 code units.
-
-_code: filename.js
-
-_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

docs.wrm/documentation/fragment.txt

@@ -1,9 +0,0 @@
-_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)

docs.wrm/documentation/index.wrm

@@ -1,126 +0,0 @@
-_title: Flatworm Docs
-
-_section: Flatworm Docs
-
-The //Flatworm Docs// rendering script is designed to be **very**
-simple, but provide enough formatting necessary for documenting
-JavaScript libraries.
-
-A lot of its inspiration came from [Read the Docs](https://github.com/readthedocs/sphinx_rtd_theme) and
-the [Sphinx](https://www.sphinx-doc.org/) project.
-
-
-_subsection: Fragments @<flatworm-fragments>
-
-Flatworm Docs are made up of fragments. A fragment is either a lone
-body of [markdown](flatworm-markdown) text, or a
-[directive](flatworm-directive) for specialized formatting, which may
-itself have body.
-
-
-_heading: Directive Format
-
-_code: fragment.txt
-
-
-_heading: Flatworm Directives @<flatworm-directive>
-
-_definition: **_section:** //TITLE//
-A //section// has its **TITLE** in an H1 font. Sections are linked
-to in //Table of Contents// and have a dividing line drawn above
-them. If an option is specified, it is avaialble as a name for
-intern linking. There should only be one ``_section:`` per page.
-
-_definition: **_subsection:** //TITLE//
-A //subsection// has its **TITLE** in an H2 font. Subsections are linked
-to in //Table of Contents// and have a dividing line drawn above
-them. If an option is specified, it is avaialble as a name for
-internal linking.
-
-_definition: **_heading:** //TITLE//
-A //heading// has its **TITLE** in an H3 font. If an option is specified,
-it is available as a name for internal linking.
-
-_definition: **_definition:** //TERM//
-A //definition// has its **TERM** bolded and the markdown body is
-indented.
-
-_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.
-
-For JavaScript files, the file is executed, with ``\/\/!`` replaced
-with the result of the last statement and ``\/\/!error`` is replaced
-with the throw error. If the error state does not agree, rendering
-fails.
-
-_definition: **_toc:**
-A //toc// injects a Table of Contents, loading each line of the
-body as a filename and recursively loads the //toc// if present,
-otherwise all the //sections// and //subsections//.
-
-_definition: **_null:**
-A //null// is used to terminated a directive. For example, after
-a //definition//, the bodies are indented, so a //null// can be
-used to reset the indentation.
-
-
-_heading: Examples
-
-_code: examples.txt
-
-_subsection: Markdown @<flatworm-markdown>
-
-The markdown is simple and does not have the flexibility of
-other dialects, but allows for **bold**, //italic//,
-__underlined__, ``monospaced``, ^^super-scripted^^ text,
-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

docs.wrm/documentation/markdown.txt

@@ -1,23 +0,0 @@
-**bold text**
-
-//italic text//
-
-__underlined text__
-
-``monospace code``
-
-^^superscript text^^
-
-- This is a list
-- With bullet points
-- With a total of three items
-
-This is separated by -- an en-dash.
-
-This is separated by --- an em-dash.
-
-This is a [Link to Ethereum](https://ethereum.org) and this
-is an [Internal Link](some-link).
-
-This is a self-titled link [[https://ethereumorg]] and this
-[[some-link]] will use the title from its directives value.

docs.wrm/getting-started.wrm

@@ -1,32 +1,48 @@
-_title: Getting Started
-
 _section: Getting Started
 
 
 _subsection: Installing
 
 The various Classes and Functions are available to be imported
-manually from sub-packages under the
-[@ethersproject](https://www.npmjs.com/search?q=%40ethersproject%2F)
+manually from sub-packages under the [@ethersproject](link-ethers-npm)
 but for most projects, the umbrella package is the easiest way to
 get started.
 
-_code: installing.txt
+_code: @lang<shell>
+
+/home/ricmoo> npm install --save ethers@next
 
 
 _subsection: Importing
 
 _heading: Node.js
 
-_code: importing-node.source
+_code: node.js require @lang<script>
+
+const { ethers } = require("ethers");
+
+_code: ES6 or TypeScript @lang<script>
+
+import { ethers } from "ethers";
+
 
 _heading: Web Browser
 
 It is generally better practice (for security reasons) to copy the
-[ethers library](https://cdn.ethers.io/lib/ethers-5.0.esm.min.js) to
-your own webserver and serve it yourself.
+[ethers library](link-ethers-js) to your own webserver and serve it
+yourself.
 
 For quick demos or prototyping though, it can be loaded in your
 Web Applications from our CDN.
 
-_code: importing-browser.txt
+
+_code: ES6 in the Browser @lang<html>
+
+<script src="https://cdn.ethers.io/lib/ethers-5.0.esm.min.js"
+        type="application/javascipt"></script>
+
+
+_code: ES3 (UMD) in the Browser @lang<html>
+
+<script src="https://cdn.ethers.io/lib/ethers-5.0.umd.min.js"
+        type="application/javascipt"></script>

docs.wrm/hacking.wrm

@@ -1,5 +1,3 @@
-_title: Hacking
-
 _section: Hacking
 
 Things to keep in mind:

docs.wrm/importing-browser.txt

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

docs.wrm/importing-node.source

@@ -1,5 +0,0 @@
-// CommonJS
-const { ethers } = require("ethers");
-
-// ES6 or TypeScript 
-const { ethers } = require("ethers");

docs.wrm/index.wrm

@@ -1,10 +1,10 @@
-_title: Documentation
+_section: Documentation
 
-_section: What is ethers?
+_subsection: What is Ethers?
 
 The ethers.js library aims to be a complete and compact library for
 interacting with the Ethereum Blockchain and its ecosystem. It was
-originally designed for use with [ethers.io](https://ethers.io/) and
+originally designed for use with [ethers.io](link-ethersio) and
 has since expanded into a much more general-purpose library.
 
 _subsection: Features
@@ -17,17 +17,14 @@ _subsection: Features
 - Meta-classes create JavaScript objects from any contract ABI,
   including **ABIv2** and **Human-Readable ABI**
 - Connect to Ethereum nodes over
-  [JSON-RPC](https://github.com/ethereum/wiki/wiki/JSON-RPC),
-  [INFURA](https://infura.io/),
-  [Etherscan](https://etherscan.io/),
-  [Nodesmith](https://nodesmith.io),
-  [Alchemy](https://alchemyapi.io),
-  or [MetaMask](https://metamask.io/).
+  [JSON-RPC](link-jsonrpc), [INFURA](link-infura),
+  [Etherscan](link-etherscan), [Alchemy](link-alchemy),
+  [Cloudflare](link-cloudflare) or [MetaMask](link-metamask).
 - **ENS names** are first-class citizens; they can be used
   anywhere an Ethereum addresses can be used
 - **Tiny** (~88kb compressed; 284kb uncompressed)
 - **Complete** functionality for all your Ethereum needs
-- Extensive [documentation](https://docs.ethers.io/)
+- Extensive [documentation](link-ethers-docs)
 - Large collection of **test cases** which are maintained and added to
 - Fully **TypeScript** ready, with definition files and full
   TypeScript source
@@ -49,12 +46,12 @@ _toc:
     contributing
     documentation
     license
-    
+
 
 _subsection: Legacy Documentation
 
 This section will be kept up to date, linking to documentation of
 older versions of the library.
 
-- [version 4.0](https://docs.ethers.io/ethers.js)
-- [version 3.0](https://docs.ethers.io/ethers.js/v3.0/html/)
+- [version 4.0](link-legacy-docs4)
+- [version 3.0](link-legacy-docs3)

docs.wrm/installing.txt

@@ -1 +0,0 @@
-/home/ricmoo> npm install --save ethers@next

docs.wrm/license.wrm

@@ -1,11 +1,8 @@
-_title: License and Copyright
-
-
-_section: License and Copyright
+_section: License and Copyright  @<license>
 
 The ethers library (including all dependencies) are available
-under the [MIT License](https://en.m.wikipedia.org/wiki/MIT_License),
-which permits a wide variety of uses.
+under the [MIT License](link-mit), which permits a wide variety
+of uses.
 
 
 _heading: MIT License

docs.wrm/migration/ethers-v4.wrm

@@ -0,0 +1,206 @@
+_section: Migration: From Ethers v4  @<migration-v4>
+
+_subsection: BigNumber
+
+_heading: Namespace
+Since [[BigNumber]] is used quite frequently, it has been moved to
+the top level of the umbrella package.
+
+_code: @lang<script>
+
+// v4
+ethers.utils.BigNumber
+ethers.utils.BigNumberish
+
+// v5
+ethers.BigNumber
+ethers.BigNumberish
+
+
+_heading: Creating Instances
+The ``bigNumberify`` method was always preferred over the constructor
+since it could short-circuit an object instantiation for [[BigNumber]
+objects (since they are immutable). This has been moved to a static
+``from`` class method.
+
+_code: @lang<script>
+
+// v4
+new ethers.utils.BigNumber(someValue)
+ethers.utils.bigNumberify(someValue);
+
+// v5
+// - Constructor is private
+// - Removed `bigNumberify`
+ethers.BigNumber.from(someValue)
+
+
+_subsection: Contracts
+
+_code: @lang<script>
+
+// @TODO
+
+
+_subsection: Errors
+
+_heading: Namespace
+All errors now belong to the [[Logger]] class and the related functions
+have been moved to [[Logger]] instances, which can include a per-package
+version string.
+
+Global error fucntions have been moved [[Logger]] class methods.
+
+_code: @lang<script>
+
+// v4
+ethers.errors.UNKNOWN_ERROR
+ethers.errors.*
+
+errors.setCensorship(censorship, permanent)
+errors.setLogLevel(logLevel)
+
+errors.checkArgumentCount(count, expectedCount, suffix)
+errors.checkNew(self, kind)
+errors.checkNormalize()
+errors.throwError(message, code, params)
+errors.warn(...)
+errors.info(...)
+
+// v5
+ethers.utils.Logger.errors.UNKNOWN_ERROR
+ethers.utils.Logger.errors.*
+
+Logger.setCensorship(censorship, permanent)
+Logger.setLogLevel(logLevel)
+
+const logger = new ethers.utils.Logger(version);
+logger.checkArgumentCount(count, expectedCount, suffix)
+logger.checkNew(self, kind)
+logger.checkNormalize()
+logger.throwError(message, code, params)
+logger.warn(...)
+logger.info(...)
+
+
+_subsection: Interface
+The [[Interface]] object has undergone the most dramatic changes.
+
+It is no longer a meta-class and now has methods that simplify handling
+contract interface operations without the need for object inspection and
+special edge cases.
+
+_heading: Functions
+
+_code: @lang<script>
+
+// v4 (example: "transfer(address to, uint amount)")
+interface.functions.transfer.encode(to, amount)
+interface.functions.transfer.decode(callData)
+
+// v5
+interface.encodeData("transfer", [ to, amount ])
+interface.decodeResult("transfer", data)
+
+// Or you can use any compatible signature or Fragment objects.
+// Notice that signature normalization is performed for you,
+// e.g. "uint" and "uint256" will be automatically converted
+interface.encodeData("transfer(address,uint)", [ to, amount ])
+interface.decodeResult("transfer(address to, uint256 amount)", data)
+
+
+_heading: Events
+
+_code: @lang<script>
+
+// v4 (example: Transfer(address indexed, address indexed, uint256)
+interface.events.Transfer.encodeTopics(values)
+interface.events.Transfer.decode(data, topics)
+
+// v5
+interface.encodeFilterTopics("Transfer", values)
+interface.encodeEventLog("Transfer", data, topics)
+
+
+_heading: Inspection
+Interrogating properties about a function or event can now (mostly) be
+done directly on the [[Fragment]] object.
+
+_code:
+
+// v4
+interface.functions.transfer.name
+interface.functions.transfer.inputs
+interface.functions.transfer.outputs
+interface.functions.transfer.payable
+interface.functions.transfer.gas
+
+// v5
+const functionFragment = interface.getFunction("transfer")
+functionFragment.name
+functionFragment.inputs
+functionFragment.outputs
+functionFragment.payable
+functionFragment.gas
+
+
+// v4; type is "call" or "transaction"
+interface.functions.transfer.type
+
+// v5; constant is true (i.e. "call") or false (i.e. "transaction")
+functionFragment.constant
+
+
+// v4
+interface.events.Transfer.anonymous
+interface.events.Transfer.inputs
+interface.events.Transfer.name
+
+// v5
+const eventFragment = interface.getEvent("Transfer");
+eventFragment.anonymous
+eventFragment.inputs
+eventFragment.name
+
+
+// v4
+const functionSig = interface.functions.transfer.signature
+const sighash = interface.functions.transfer.sighash
+
+const eventSig = interface.events.Transfer.signature
+const topic = interface.events.Transfer.topic
+
+// v5
+const functionSig = functionFragment.format()
+const sighash = interface.getSighash(functionFragment)
+
+const eventSig = eventFragment.format()
+const topic = interface.getTopic(eventFragment)
+
+
+_subsection: Utilities
+
+_heading: Renaming
+
+_code: @lang<script>
+
+// @TODO
+
+_subsection: Wallet
+
+_heading: Mnemonic Phrases
+The **mnemonic** phrase and related properties have been merged into
+a single ``mnemonic`` object, which also now includes the ``locale``.
+
+_code: @lang<script>
+
+// v4
+wallet.mnemonic
+wallet.path
+
+// v5
+// - Mnemonic phrase and path are a Mnemonic object
+// - Note: wallet.mnemonic is null if there is no mnemonic
+wallet.mnemonic.phrase
+wallet.mnemonic.path
+

docs.wrm/migration/index.wrm

@@ -1,13 +1,8 @@
-_title: Migration Guide
+_section: Migration Guide @<migration>
 
-_section: Migration Guide
+Here are some migration guides when upgrading from older versions
+of Ethers or other libraries.
 
-Migratimg...
-
-_subsection: From Web3
-
-test
-
-_subsection: From ethers v4
-
-test
+_toc:
+    web3
+    ethers-v4

docs.wrm/migration/web3.wrm

@@ -0,0 +1,13 @@
+_section: Migration: From Web3.js
+
+TODO
+
+_subsection: Contracts
+
+_subsection: Providers
+
+_subsection: Numbers
+
+_subsection: Utilities
+
+

docs.wrm/quick-start.wrm

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

docs.wrm/redirects.json

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

docs.wrm/testing/index.wrm

@@ -1,5 +1,3 @@
-_title: Testing
-
 _section: Testing
 
 Here goes info about testing

docs/README.md

@@ -4,14 +4,18 @@ Documentation: [html](https://docs-beta.ethers.io/)
 
 -----
 
+Documentation
+=============
 
-What is ethers?
-===============
+
+
+What is Ethers?
+---------------
 
 
 The ethers.js library aims to be a complete and compact library for
 interacting with the Ethereum Blockchain and its ecosystem. It was
-originally designed for use with [ethers.io](https://ethers.io/) and
+originally designed for use with [ethers.io](Users/ricmoo/Development/ethers/ethers.js-v5/https:/ethers.io) and
 has since expanded into a much more general-purpose library.
 
 
@@ -25,11 +29,11 @@ Features
 * Import and export **JSON wallets** (Geth, Parity and crowdsale)
 * Import and export BIP 39 **mnemonic phrases** (12 word backup phrases) and HD Wallets (English, Italian, Japanese, Korean, Simplified Chinese, Traditional Chinese; more coming soon)
 * Meta-classes create JavaScript objects from any contract ABI, including **ABIv2** and **Human-Readable ABI**
-* Connect to Ethereum nodes over [JSON-RPC](https://github.com/ethereum/wiki/wiki/JSON-RPC), [INFURA](https://infura.io/), [Etherscan](https://etherscan.io/), [Nodesmith](https://nodesmith.io), [Alchemy](https://alchemyapi.io), or [MetaMask](https://metamask.io/).
+* Connect to Ethereum nodes over [JSON-RPC](Users/ricmoo/Development/ethers/ethers.js-v5/https:/github.com/ethereum/wiki/wiki/JSON-RPC), [INFURA](Users/ricmoo/Development/ethers/ethers.js-v5/https:/infura.io), [Etherscan](Users/ricmoo/Development/ethers/ethers.js-v5/https:/etherscan.io), [Alchemy](Users/ricmoo/Development/ethers/ethers.js-v5/https:/alchemyapi.io), [Cloudflare](Users/ricmoo/Development/ethers/ethers.js-v5/https:/developers.cloudflare.com/distributed-web/ethereum-gateway) or [MetaMask](Users/ricmoo/Development/ethers/ethers.js-v5/https:/metamask.io).
 * **ENS names** are first-class citizens; they can be used anywhere an Ethereum addresses can be used
 * **Tiny** (~88kb compressed; 284kb uncompressed)
 * **Complete** functionality for all your Ethereum needs
-* Extensive [documentation](https://docs.ethers.io/)
+* Extensive [documentation](Users/ricmoo/Development/ethers/ethers.js-v5/https:/docs.ethers.io)
 * Large collection of **test cases** which are maintained and added to
 * Fully **TypeScript** ready, with definition files and full TypeScript source
 * **MIT License** (including *ALL* dependencies); completely open source to do with as you please
@@ -50,11 +54,24 @@ Developer Documentation
     * [Gas Price](concepts/gas)
     * [Gas Limit](concepts/gas)
 * [Application Programming Interface](api)
-  * [Contracts](api/contract)
-    * [Buckets](api/contract)
+  * [Contract Interaction](api/contract)
+    * [Contract](api/contract/contract)
+      * [Properties](api/contract/contract)
+      * [Methods](api/contract/contract)
+      * [Events](api/contract/contract)
+      * [Meta-Class](api/contract/contract)
+    * [Example: ERC-20 Contract](api/contract/example)
+      * [Connecting to a Contract](api/contract/example)
+      * [Properties ^^//(inheritted from [[contract]])//^^](api/contract/example)
+      * [Methods ^^//(inheritted from [[contract]])//^^](api/contract/example)
+      * [Events ^^//(inheritted from Contract)//^^](api/contract/example)
+      * [Meta-Class Methods ^^//(added at Runtime)//^^](api/contract/example)
+      * [Meta-Class Filters ^^//(added at Runtime)//^^](api/contract/example)
   * [Signers](api/signer)
     * [Signer](api/signer)
-    * [Wallet inherits Signer](api/signer)
+    * [Wallet](api/signer)
+    * [VoidSigner](api/signer)
+    * [ExternallyOwnedAccount](api/signer)
   * [Providers](api/providers)
     * [Provider](api/providers/provider)
       * [Accounts Methods](api/providers/provider)
@@ -65,25 +82,48 @@ Developer Documentation
       * [Transactions Methods](api/providers/provider)
       * [Event Emitter Methods](api/providers/provider)
       * [Inspection Methods](api/providers/provider)
-    * [JSON-RPC Provider](api/providers/jsonrpc-provider)
-      * [JsonRpcProvider](api/providers/jsonrpc-provider)
+    * [JsonRpcProvider](api/providers/jsonrpc-provider)
       * [JsonRpcSigner](api/providers/jsonrpc-provider)
       * [JsonRpcUncheckedSigner](api/providers/jsonrpc-provider)
     * [API Providers](api/providers/api-providers)
       * [EtherscanProvider](api/providers/api-providers)
       * [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)
+      * [UrlJsonRpcProvider](api/providers/other)
+      * [Web3Provider](api/providers/other)
     * [Types](api/providers/types)
-      * [Blocks](api/providers/types)
+      * [BlockTag](api/providers/types)
+      * [Network](api/providers/types)
+      * [Block](api/providers/types)
       * [Events and Logs](api/providers/types)
       * [Transactions](api/providers/types)
   * [Utilities](api/utils)
+    * [Application Binary Interface](api/utils/abi)
+      * [Interface](api/utils/abi/interface)
+        * [Creating Instances](api/utils/abi/interface)
+        * [Properties](api/utils/abi/interface)
+        * [Formatting](api/utils/abi/interface)
+        * [Fragment Access](api/utils/abi/interface)
+        * [Signature and Topic Hashes](api/utils/abi/interface)
+        * [Encoding Data](api/utils/abi/interface)
+        * [Decoding Data](api/utils/abi/interface)
+        * [Parsing](api/utils/abi/interface)
+        * [Types](api/utils/abi/interface)
+        * [Specifying Fragments](api/utils/abi/interface)
+      * [Fragments](api/utils/abi/fragments)
+        * [Formats](api/utils/abi/fragments)
+        * [Fragment](api/utils/abi/fragments)
+        * [ConstructorFragment](api/utils/abi/fragments)
+        * [EventFragment](api/utils/abi/fragments)
+        * [FunctionFragment](api/utils/abi/fragments)
+        * [ParamType](api/utils/abi/fragments)
     * [Addresses](api/utils/address)
+      * [Address Formats](api/utils/address)
+      * [Functions](api/utils/address)
     * [BigNumber](api/utils/bignumber)
       * [Types](api/utils/bignumber)
       * [Creating Instances](api/utils/bignumber)
@@ -96,6 +136,7 @@ Developer Documentation
       * [Array Manipulation](api/utils/bytes)
       * [Hexstring Manipulation](api/utils/bytes)
       * [Signature Conversion](api/utils/bytes)
+      * [Random Bytes](api/utils/bytes)
     * [Constants](api/utils/constants)
       * [Bytes](api/utils/constants)
       * [Strings](api/utils/constants)
@@ -103,28 +144,104 @@ Developer Documentation
     * [Display Logic and Input](api/utils/display-logic)
       * [Units](api/utils/display-logic)
       * [Functions](api/utils/display-logic)
+    * [Encoding Utilities](api/utils/encoding)
+      * [Base58](api/utils/encoding)
+      * [Base64](api/utils/encoding)
+      * [Recursive-Length Prefix](api/utils/encoding)
     * [FixedNumber](api/utils/fixednumber)
-      * [Types](api/utils/fixednumber)
       * [Creating Instances](api/utils/fixednumber)
       * [Properties](api/utils/fixednumber)
       * [Methods](api/utils/fixednumber)
+      * [FixedFormat](api/utils/fixednumber)
     * [Hashing Algorithms](api/utils/hashing)
       * [Cryptographic Hashing](api/utils/hashing)
       * [Common Hashing Helpers](api/utils/hashing)
       * [Solidity Hashing Algorithms](api/utils/hashing)
+    * [HD Wallet](api/utils/hdnode)
+      * [Types](api/utils/hdnode)
+      * [HDNode](api/utils/hdnode)
+      * [Other Functions](api/utils/hdnode)
+    * [Logging](api/utils/logger)
+      * [Logger](api/utils/logger)
+      * [Errors](api/utils/logger)
+      * [Log Levels](api/utils/logger)
+    * [Property Utilities](api/utils/properties)
+    * [Signing Key](api/utils/signing-key)
+      * [Other Functions](api/utils/signing-key)
     * [Strings](api/utils/strings)
       * [Bytes32String](api/utils/strings)
       * [UTF-8 Strings](api/utils/strings)
+      * [UnicodeNormalizationForm](api/utils/strings)
+      * [Custom UTF-8 Error Handling](api/utils/strings)
+    * [Transactions](api/utils/transactions)
+      * [Types](api/utils/transactions)
+      * [Functions](api/utils/transactions)
+    * [Web Utilities](api/utils/web)
+    * [Wordlists](api/utils/wordlists)
+      * [Wordlist](api/utils/wordlists)
+      * [Languages](api/utils/wordlists)
+  * [Other Libraries](api/other)
+    * [Assembly](api/other/assembly)
+      * [Ethers ASM Dialect](api/other/assembly/dialect)
+        * [Opcodes](api/other/assembly/dialect)
+        * [Labels](api/other/assembly/dialect)
+        * [Literals](api/other/assembly/dialect)
+        * [Comments](api/other/assembly/dialect)
+        * [Scopes](api/other/assembly/dialect)
+        * [Data Segment](api/other/assembly/dialect)
+        * [Links](api/other/assembly/dialect)
+        * [Stack Placeholders](api/other/assembly/dialect)
+        * [Evaluation and Excution](api/other/assembly/dialect)
+      * [Utilities](api/other/assembly/api)
+        * [Assembler](api/other/assembly/api)
+        * [Disassembler](api/other/assembly/api)
+        * [Opcode](api/other/assembly/api)
+      * [Abstract Syntax Tree](api/other/assembly/ast)
+        * [Types](api/other/assembly/ast)
+        * [Nodes](api/other/assembly/ast)
+    * [Hardware Wallets](api/other/hardware)
+      * [LedgerSigner](api/other/hardware)
+* [Command Line Interfaces](cli)
+  * [Sandbox Utility](cli/ethers)
+    * [Help](cli/ethers)
+    * [Examples](cli/ethers)
+  * [Assembler](cli/asm)
+    * [Help](cli/asm)
+    * [Example Input Files](cli/asm)
+    * [Assembler Examples](cli/asm)
+    * [Disassembler Examples](cli/asm)
+  * [Ethereum Naming Service](cli/ens)
+    * [Help](cli/ens)
+    * [Examples](cli/ens)
+  * [TypeScript](cli/typescript)
+    * [Help](cli/typescript)
+    * [Examples](cli/typescript)
+  * [Making Your Own](cli/plugin)
+    * [CLI](cli/plugin)
+    * [Plugin](cli/plugin)
+    * [ArgParser](cli/plugin)
 * [Cookbook](cookbook)
 * [Migration Guide](migration)
-  * [From Web3](migration)
-  * [From ethers v4](migration)
+  * [Migration: From Web3.js](migration/web3)
+    * [Contracts](migration/web3)
+    * [Providers](migration/web3)
+    * [Numbers](migration/web3)
+    * [Utilities](migration/web3)
+  * [Migration: From Ethers v4](migration/ethers-v4)
+    * [BigNumber](migration/ethers-v4)
+    * [Contracts](migration/ethers-v4)
+    * [Errors](migration/ethers-v4)
+    * [Interface](migration/ethers-v4)
+    * [Utilities](migration/ethers-v4)
+    * [Wallet](migration/ethers-v4)
 * [Testing](testing)
 * [Contributing and Hacking](contributing)
   * [Building](contributing)
 * [Flatworm Docs](documentation)
   * [Fragments](documentation)
   * [Markdown](documentation)
+  * [Configuration](documentation)
+  * [Extended Directive Functions](documentation)
 * [License and Copyright](license)
 
 
@@ -137,10 +254,10 @@ older versions of the library.
 
 
 
-* [version 4.0](https://docs.ethers.io/ethers.js)
-* [version 3.0](https://docs.ethers.io/ethers.js/v3.0/html/)
+* [version 4.0](Users/ricmoo/Development/ethers/ethers.js-v5/https:/docs.ethers.io/ethers.js)
+* [version 3.0](Users/ricmoo/Development/ethers/ethers.js-v5/https:/docs.ethers.io/ethers.js/v3.0/html)
 
 
 
 -----
-**Content Hash:** f1da4df3feeb06a567657ae41d8498ea3315f68d05dc2f9e86c2858b5d2b2f89
+**Content Hash:** 1ccc27c4ba6e59efa2be69cc0fb345ea9c397f1f4444d08ec13780d0d1a46b60

docs/api/README.md

@@ -4,19 +4,31 @@ Documentation: [html](https://docs-beta.ethers.io/)
 
 -----
 
-
-Application Programming Interface (API)
-=======================================
+Application Programming Interface
+=================================
 
 
 Here...
 
 
-* [Contracts](contract)
-  * [Buckets](contract)
+* [Contract Interaction](contract)
+  * [Contract](contract/contract)
+    * [Properties](contract/contract)
+    * [Methods](contract/contract)
+    * [Events](contract/contract)
+    * [Meta-Class](contract/contract)
+  * [Example: ERC-20 Contract](contract/example)
+    * [Connecting to a Contract](contract/example)
+    * [Properties ^^//(inheritted from [[contract]])//^^](contract/example)
+    * [Methods ^^//(inheritted from [[contract]])//^^](contract/example)
+    * [Events ^^//(inheritted from Contract)//^^](contract/example)
+    * [Meta-Class Methods ^^//(added at Runtime)//^^](contract/example)
+    * [Meta-Class Filters ^^//(added at Runtime)//^^](contract/example)
 * [Signers](signer)
   * [Signer](signer)
-  * [Wallet inherits Signer](signer)
+  * [Wallet](signer)
+  * [VoidSigner](signer)
+  * [ExternallyOwnedAccount](signer)
 * [Providers](providers)
   * [Provider](providers/provider)
     * [Accounts Methods](providers/provider)
@@ -27,25 +39,48 @@ Here...
     * [Transactions Methods](providers/provider)
     * [Event Emitter Methods](providers/provider)
     * [Inspection Methods](providers/provider)
-  * [JSON-RPC Provider](providers/jsonrpc-provider)
-    * [JsonRpcProvider](providers/jsonrpc-provider)
+  * [JsonRpcProvider](providers/jsonrpc-provider)
     * [JsonRpcSigner](providers/jsonrpc-provider)
     * [JsonRpcUncheckedSigner](providers/jsonrpc-provider)
   * [API Providers](providers/api-providers)
     * [EtherscanProvider](providers/api-providers)
     * [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)
+    * [UrlJsonRpcProvider](providers/other)
+    * [Web3Provider](providers/other)
   * [Types](providers/types)
-    * [Blocks](providers/types)
+    * [BlockTag](providers/types)
+    * [Network](providers/types)
+    * [Block](providers/types)
     * [Events and Logs](providers/types)
     * [Transactions](providers/types)
 * [Utilities](utils)
+  * [Application Binary Interface](utils/abi)
+    * [Interface](utils/abi/interface)
+      * [Creating Instances](utils/abi/interface)
+      * [Properties](utils/abi/interface)
+      * [Formatting](utils/abi/interface)
+      * [Fragment Access](utils/abi/interface)
+      * [Signature and Topic Hashes](utils/abi/interface)
+      * [Encoding Data](utils/abi/interface)
+      * [Decoding Data](utils/abi/interface)
+      * [Parsing](utils/abi/interface)
+      * [Types](utils/abi/interface)
+      * [Specifying Fragments](utils/abi/interface)
+    * [Fragments](utils/abi/fragments)
+      * [Formats](utils/abi/fragments)
+      * [Fragment](utils/abi/fragments)
+      * [ConstructorFragment](utils/abi/fragments)
+      * [EventFragment](utils/abi/fragments)
+      * [FunctionFragment](utils/abi/fragments)
+      * [ParamType](utils/abi/fragments)
   * [Addresses](utils/address)
+    * [Address Formats](utils/address)
+    * [Functions](utils/address)
   * [BigNumber](utils/bignumber)
     * [Types](utils/bignumber)
     * [Creating Instances](utils/bignumber)
@@ -58,6 +93,7 @@ Here...
     * [Array Manipulation](utils/bytes)
     * [Hexstring Manipulation](utils/bytes)
     * [Signature Conversion](utils/bytes)
+    * [Random Bytes](utils/bytes)
   * [Constants](utils/constants)
     * [Bytes](utils/constants)
     * [Strings](utils/constants)
@@ -65,20 +101,65 @@ Here...
   * [Display Logic and Input](utils/display-logic)
     * [Units](utils/display-logic)
     * [Functions](utils/display-logic)
+  * [Encoding Utilities](utils/encoding)
+    * [Base58](utils/encoding)
+    * [Base64](utils/encoding)
+    * [Recursive-Length Prefix](utils/encoding)
   * [FixedNumber](utils/fixednumber)
-    * [Types](utils/fixednumber)
     * [Creating Instances](utils/fixednumber)
     * [Properties](utils/fixednumber)
     * [Methods](utils/fixednumber)
+    * [FixedFormat](utils/fixednumber)
   * [Hashing Algorithms](utils/hashing)
     * [Cryptographic Hashing](utils/hashing)
     * [Common Hashing Helpers](utils/hashing)
     * [Solidity Hashing Algorithms](utils/hashing)
+  * [HD Wallet](utils/hdnode)
+    * [Types](utils/hdnode)
+    * [HDNode](utils/hdnode)
+    * [Other Functions](utils/hdnode)
+  * [Logging](utils/logger)
+    * [Logger](utils/logger)
+    * [Errors](utils/logger)
+    * [Log Levels](utils/logger)
+  * [Property Utilities](utils/properties)
+  * [Signing Key](utils/signing-key)
+    * [Other Functions](utils/signing-key)
   * [Strings](utils/strings)
     * [Bytes32String](utils/strings)
     * [UTF-8 Strings](utils/strings)
+    * [UnicodeNormalizationForm](utils/strings)
+    * [Custom UTF-8 Error Handling](utils/strings)
+  * [Transactions](utils/transactions)
+    * [Types](utils/transactions)
+    * [Functions](utils/transactions)
+  * [Web Utilities](utils/web)
+  * [Wordlists](utils/wordlists)
+    * [Wordlist](utils/wordlists)
+    * [Languages](utils/wordlists)
+* [Other Libraries](other)
+  * [Assembly](other/assembly)
+    * [Ethers ASM Dialect](other/assembly/dialect)
+      * [Opcodes](other/assembly/dialect)
+      * [Labels](other/assembly/dialect)
+      * [Literals](other/assembly/dialect)
+      * [Comments](other/assembly/dialect)
+      * [Scopes](other/assembly/dialect)
+      * [Data Segment](other/assembly/dialect)
+      * [Links](other/assembly/dialect)
+      * [Stack Placeholders](other/assembly/dialect)
+      * [Evaluation and Excution](other/assembly/dialect)
+    * [Utilities](other/assembly/api)
+      * [Assembler](other/assembly/api)
+      * [Disassembler](other/assembly/api)
+      * [Opcode](other/assembly/api)
+    * [Abstract Syntax Tree](other/assembly/ast)
+      * [Types](other/assembly/ast)
+      * [Nodes](other/assembly/ast)
+  * [Hardware Wallets](other/hardware)
+    * [LedgerSigner](other/hardware)
 
 
 
 -----
-**Content Hash:** 82f760f38f47d32016d3fca512c5dc75539d885d13138f1faa15f4be82edf8aa
+**Content Hash:** 792936ddc8c609e435d356c2bfde1adacf9f0b5b708481720f22081f1a61f73d