From f5336c19b1adcb5e992745b8a0561eaf8f1f1138 Mon Sep 17 00:00:00 2001 From: Richard Moore Date: Mon, 5 Sep 2022 16:14:43 -0400 Subject: [PATCH] Initial code drop for v6-beta-exports. --- .gitignore | 3 + .npmignore | 26 + package-commonjs.json | 3 + package.json | 131 ++ reporter.cjs | 213 +++ rollup.config.js | 47 + src.ts/_admin/update-version-const.ts | 8 + src.ts/_admin/utils/fs.ts | 9 + src.ts/_admin/utils/json.ts | 32 + src.ts/_admin/utils/path.ts | 14 + src.ts/_tests/test-abi.ts | 43 + src.ts/_tests/test-address.ts | 132 ++ src.ts/_tests/test-contract.ts | 99 ++ src.ts/_tests/test-crypto-algoswap.ts | 116 ++ src.ts/_tests/test-crypto.ts | 238 +++ src.ts/_tests/test-hash-typeddata.ts | 20 + src.ts/_tests/test-hash.ts | 110 ++ src.ts/_tests/test-rlp.ts | 101 ++ src.ts/_tests/test-transaction.ts | 306 ++++ src.ts/_tests/test-wallet-hd.ts | 155 ++ src.ts/_tests/test-wallet-json.ts | 65 + src.ts/_tests/test-wallet-mnemonic.ts | 143 ++ src.ts/_tests/test-wallet.ts | 83 ++ src.ts/_tests/test-wordlists.ts | 79 + src.ts/_tests/types.ts | 245 +++ src.ts/_tests/utils.ts | 32 + src.ts/_version.ts | 1 + src.ts/abi/abi-coder.ts | 95 ++ src.ts/abi/bytes32.ts | 37 + src.ts/abi/coders/abstract-coder.ts | 318 ++++ src.ts/abi/coders/address.ts | 33 + src.ts/abi/coders/anonymous.ts | 25 + src.ts/abi/coders/array.ts | 208 +++ src.ts/abi/coders/boolean.ts | 25 + src.ts/abi/coders/bytes.ts | 38 + src.ts/abi/coders/fixed-bytes.ts | 36 + src.ts/abi/coders/null.ts | 25 + src.ts/abi/coders/number.ts | 65 + src.ts/abi/coders/string.ts | 26 + src.ts/abi/coders/tuple.ts | 66 + src.ts/abi/fragments.ts | 1091 ++++++++++++++ src.ts/abi/index.ts | 38 + src.ts/abi/interface.ts | 905 ++++++++++++ src.ts/abi/typed.ts | 254 ++++ src.ts/address/address.ts | 125 ++ src.ts/address/checks.ts | 54 + src.ts/address/contract-address.ts | 40 + src.ts/address/index.ts | 16 + src.ts/constants/addresses.ts | 6 + src.ts/constants/hashes.ts | 5 + src.ts/constants/index.ts | 14 + src.ts/constants/numbers.ts | 57 + src.ts/constants/strings.ts | 9 + src.ts/contract/contract.ts | 763 ++++++++++ src.ts/contract/factory.ts | 97 ++ src.ts/contract/index.ts | 19 + src.ts/contract/types.ts | 83 ++ src.ts/contract/wrappers.ts | 99 ++ src.ts/crypto/crypto-browser.ts | 73 + src.ts/crypto/crypto.ts | 4 + src.ts/crypto/hmac.ts | 26 + src.ts/crypto/index.ts | 45 + src.ts/crypto/keccak.ts | 26 + src.ts/crypto/pbkdf2.ts | 27 + src.ts/crypto/random.ts | 21 + src.ts/crypto/ripemd160.ts | 26 + src.ts/crypto/scrypt.ts | 48 + src.ts/crypto/sha2.ts | 44 + src.ts/crypto/signature.ts | 261 ++++ src.ts/crypto/signing-key.ts | 130 ++ src.ts/ethers.ts | 147 ++ src.ts/hash/id.ts | 6 + src.ts/hash/index.ts | 10 + src.ts/hash/message.ts | 13 + src.ts/hash/namehash.ts | 84 ++ src.ts/hash/solidity.ts | 115 ++ src.ts/hash/typed-data.ts | 520 +++++++ src.ts/index.ts | 6 + src.ts/providers/abstract-provider.ts | 1314 +++++++++++++++++ src.ts/providers/abstract-signer.ts | 199 +++ src.ts/providers/common-networks.ts | 102 ++ src.ts/providers/community.ts | 24 + src.ts/providers/contracts.ts | 21 + src.ts/providers/default-provider.ts | 89 ++ src.ts/providers/ens-resolver.ts | 535 +++++++ src.ts/providers/formatter.ts | 442 ++++++ src.ts/providers/index.ts | 92 ++ src.ts/providers/network.ts | 236 +++ src.ts/providers/pagination.ts | 8 + src.ts/providers/plugins-network.ts | 143 ++ src.ts/providers/provider-alchemy.ts | 114 ++ src.ts/providers/provider-ankr.ts | 77 + src.ts/providers/provider-cloudflare.ts | 17 + src.ts/providers/provider-etherscan.ts | 508 +++++++ src.ts/providers/provider-fallback.ts | 555 +++++++ src.ts/providers/provider-infura.ts | 89 ++ .../providers/provider-ipcsocket-browser.ts | 3 + src.ts/providers/provider-ipcsocket.ts | 98 ++ src.ts/providers/provider-jsonrpc.ts | 853 +++++++++++ src.ts/providers/provider-pocket.ts | 99 ++ src.ts/providers/provider-socket.ts | 259 ++++ src.ts/providers/provider-websocket.ts | 46 + src.ts/providers/provider.ts | 1097 ++++++++++++++ src.ts/providers/signer.ts | 149 ++ src.ts/providers/subscriber-connection.ts | 53 + src.ts/providers/subscriber-filterid.ts | 133 ++ src.ts/providers/subscriber-hotswap.ts | 41 + src.ts/providers/subscriber-polling.ts | 203 +++ src.ts/providers/subscriber.ts | 56 + src.ts/providers/ws-browser.ts | 11 + src.ts/providers/ws.ts | 3 + src.ts/thirdparty.d.ts | 16 + src.ts/transaction/accesslist.ts | 43 + src.ts/transaction/address.ts | 15 + src.ts/transaction/index.ts | 15 + src.ts/transaction/transaction.ts | 673 +++++++++ src.ts/utils/base58.ts | 52 + src.ts/utils/base64-browser.ts | 25 + src.ts/utils/base64.ts | 12 + src.ts/utils/data.ts | 84 ++ src.ts/utils/errors.ts | 285 ++++ src.ts/utils/events.ts | 36 + src.ts/utils/fetch.ts | 657 +++++++++ src.ts/utils/fixednumber.ts | 396 +++++ src.ts/utils/geturl-browser.ts | 76 + src.ts/utils/geturl.ts | 97 ++ src.ts/utils/index.ts | 99 ++ src.ts/utils/logger.ts | 254 ++++ src.ts/utils/maths.ts | 134 ++ src.ts/utils/properties.ts | 110 ++ src.ts/utils/rlp-decode.ts | 108 ++ src.ts/utils/rlp-encode.ts | 61 + src.ts/utils/rlp.ts | 5 + src.ts/utils/storage.ts | 10 + src.ts/utils/units.ts | 63 + src.ts/utils/utf8.ts | 285 ++++ src.ts/wallet/base-wallet.ts | 84 ++ src.ts/wallet/hdwallet.ts | 352 +++++ src.ts/wallet/index.ts | 22 + src.ts/wallet/json-crowdsale.ts | 54 + src.ts/wallet/json-keystore.ts | 367 +++++ src.ts/wallet/mnemonic.ts | 154 ++ src.ts/wallet/utils.ts | 146 ++ src.ts/wallet/wallet.ts | 166 +++ src.ts/wordlists/bit-reader.ts | 32 + src.ts/wordlists/decode-owl.ts | 52 + src.ts/wordlists/decode-owla.ts | 30 + src.ts/wordlists/generation/encode-latin.ts | 370 +++++ src.ts/wordlists/index.ts | 7 + src.ts/wordlists/lang-cz.ts | 10 + src.ts/wordlists/lang-en.ts | 10 + src.ts/wordlists/lang-es.ts | 11 + src.ts/wordlists/lang-fr.ts | 11 + src.ts/wordlists/lang-it.ts | 10 + src.ts/wordlists/lang-ja.ts | 157 ++ src.ts/wordlists/lang-ko.ts | 83 ++ src.ts/wordlists/lang-pt.ts | 10 + src.ts/wordlists/lang-zh.ts | 83 ++ src.ts/wordlists/wordlist-owl.ts | 57 + src.ts/wordlists/wordlist-owla.ts | 18 + src.ts/wordlists/wordlist.ts | 22 + src.ts/wordlists/wordlists-browser.ts | 10 + src.ts/wordlists/wordlists-extra.ts | 15 + src.ts/wordlists/wordlists.ts | 15 + testcases/README.md | 4 + testcases/abi.json.gz | Bin 0 -> 1118569 bytes testcases/accounts.json.gz | Bin 0 -> 26153 bytes testcases/create.json.gz | Bin 0 -> 5810 bytes testcases/create2.json.gz | Bin 0 -> 21247 bytes testcases/hashes.json.gz | Bin 0 -> 68270 bytes testcases/hmac.json.gz | Bin 0 -> 34364 bytes testcases/mnemonics.json.gz | Bin 0 -> 857561 bytes testcases/namehash.json.gz | Bin 0 -> 362 bytes testcases/pbkdf.json.gz | Bin 0 -> 49108 bytes testcases/rlp.json.gz | Bin 0 -> 1763 bytes testcases/transaction.json.gz | Bin 0 -> 346037 bytes testcases/transactions.json.gz | Bin 0 -> 383526 bytes testcases/typed-data.json.gz | Bin 0 -> 40762 bytes testcases/wallets.json.gz | Bin 0 -> 2798 bytes testcases/wordlists.json.gz | Bin 0 -> 62745 bytes tsconfig.base.json | 30 + tsconfig.commonjs.json | 10 + tsconfig.esm.json | 7 + tsconfig.types.json | 12 + 184 files changed, 22459 insertions(+) create mode 100644 .gitignore create mode 100644 .npmignore create mode 100644 package-commonjs.json create mode 100644 package.json create mode 100644 reporter.cjs create mode 100644 rollup.config.js create mode 100644 src.ts/_admin/update-version-const.ts create mode 100644 src.ts/_admin/utils/fs.ts create mode 100644 src.ts/_admin/utils/json.ts create mode 100644 src.ts/_admin/utils/path.ts create mode 100644 src.ts/_tests/test-abi.ts create mode 100644 src.ts/_tests/test-address.ts create mode 100644 src.ts/_tests/test-contract.ts create mode 100644 src.ts/_tests/test-crypto-algoswap.ts create mode 100644 src.ts/_tests/test-crypto.ts create mode 100644 src.ts/_tests/test-hash-typeddata.ts create mode 100644 src.ts/_tests/test-hash.ts create mode 100644 src.ts/_tests/test-rlp.ts create mode 100644 src.ts/_tests/test-transaction.ts create mode 100644 src.ts/_tests/test-wallet-hd.ts create mode 100644 src.ts/_tests/test-wallet-json.ts create mode 100644 src.ts/_tests/test-wallet-mnemonic.ts create mode 100644 src.ts/_tests/test-wallet.ts create mode 100644 src.ts/_tests/test-wordlists.ts create mode 100644 src.ts/_tests/types.ts create mode 100644 src.ts/_tests/utils.ts create mode 100644 src.ts/_version.ts create mode 100644 src.ts/abi/abi-coder.ts create mode 100644 src.ts/abi/bytes32.ts create mode 100644 src.ts/abi/coders/abstract-coder.ts create mode 100644 src.ts/abi/coders/address.ts create mode 100644 src.ts/abi/coders/anonymous.ts create mode 100644 src.ts/abi/coders/array.ts create mode 100644 src.ts/abi/coders/boolean.ts create mode 100644 src.ts/abi/coders/bytes.ts create mode 100644 src.ts/abi/coders/fixed-bytes.ts create mode 100644 src.ts/abi/coders/null.ts create mode 100644 src.ts/abi/coders/number.ts create mode 100644 src.ts/abi/coders/string.ts create mode 100644 src.ts/abi/coders/tuple.ts create mode 100644 src.ts/abi/fragments.ts create mode 100644 src.ts/abi/index.ts create mode 100644 src.ts/abi/interface.ts create mode 100644 src.ts/abi/typed.ts create mode 100644 src.ts/address/address.ts create mode 100644 src.ts/address/checks.ts create mode 100644 src.ts/address/contract-address.ts create mode 100644 src.ts/address/index.ts create mode 100644 src.ts/constants/addresses.ts create mode 100644 src.ts/constants/hashes.ts create mode 100644 src.ts/constants/index.ts create mode 100644 src.ts/constants/numbers.ts create mode 100644 src.ts/constants/strings.ts create mode 100644 src.ts/contract/contract.ts create mode 100644 src.ts/contract/factory.ts create mode 100644 src.ts/contract/index.ts create mode 100644 src.ts/contract/types.ts create mode 100644 src.ts/contract/wrappers.ts create mode 100644 src.ts/crypto/crypto-browser.ts create mode 100644 src.ts/crypto/crypto.ts create mode 100644 src.ts/crypto/hmac.ts create mode 100644 src.ts/crypto/index.ts create mode 100644 src.ts/crypto/keccak.ts create mode 100644 src.ts/crypto/pbkdf2.ts create mode 100644 src.ts/crypto/random.ts create mode 100644 src.ts/crypto/ripemd160.ts create mode 100644 src.ts/crypto/scrypt.ts create mode 100644 src.ts/crypto/sha2.ts create mode 100644 src.ts/crypto/signature.ts create mode 100644 src.ts/crypto/signing-key.ts create mode 100644 src.ts/ethers.ts create mode 100644 src.ts/hash/id.ts create mode 100644 src.ts/hash/index.ts create mode 100644 src.ts/hash/message.ts create mode 100644 src.ts/hash/namehash.ts create mode 100644 src.ts/hash/solidity.ts create mode 100644 src.ts/hash/typed-data.ts create mode 100644 src.ts/index.ts create mode 100644 src.ts/providers/abstract-provider.ts create mode 100644 src.ts/providers/abstract-signer.ts create mode 100644 src.ts/providers/common-networks.ts create mode 100644 src.ts/providers/community.ts create mode 100644 src.ts/providers/contracts.ts create mode 100644 src.ts/providers/default-provider.ts create mode 100644 src.ts/providers/ens-resolver.ts create mode 100644 src.ts/providers/formatter.ts create mode 100644 src.ts/providers/index.ts create mode 100644 src.ts/providers/network.ts create mode 100644 src.ts/providers/pagination.ts create mode 100644 src.ts/providers/plugins-network.ts create mode 100644 src.ts/providers/provider-alchemy.ts create mode 100644 src.ts/providers/provider-ankr.ts create mode 100644 src.ts/providers/provider-cloudflare.ts create mode 100644 src.ts/providers/provider-etherscan.ts create mode 100644 src.ts/providers/provider-fallback.ts create mode 100644 src.ts/providers/provider-infura.ts create mode 100644 src.ts/providers/provider-ipcsocket-browser.ts create mode 100644 src.ts/providers/provider-ipcsocket.ts create mode 100644 src.ts/providers/provider-jsonrpc.ts create mode 100644 src.ts/providers/provider-pocket.ts create mode 100644 src.ts/providers/provider-socket.ts create mode 100644 src.ts/providers/provider-websocket.ts create mode 100644 src.ts/providers/provider.ts create mode 100644 src.ts/providers/signer.ts create mode 100644 src.ts/providers/subscriber-connection.ts create mode 100644 src.ts/providers/subscriber-filterid.ts create mode 100644 src.ts/providers/subscriber-hotswap.ts create mode 100644 src.ts/providers/subscriber-polling.ts create mode 100644 src.ts/providers/subscriber.ts create mode 100644 src.ts/providers/ws-browser.ts create mode 100644 src.ts/providers/ws.ts create mode 100644 src.ts/thirdparty.d.ts create mode 100644 src.ts/transaction/accesslist.ts create mode 100644 src.ts/transaction/address.ts create mode 100644 src.ts/transaction/index.ts create mode 100644 src.ts/transaction/transaction.ts create mode 100644 src.ts/utils/base58.ts create mode 100644 src.ts/utils/base64-browser.ts create mode 100644 src.ts/utils/base64.ts create mode 100644 src.ts/utils/data.ts create mode 100644 src.ts/utils/errors.ts create mode 100644 src.ts/utils/events.ts create mode 100644 src.ts/utils/fetch.ts create mode 100644 src.ts/utils/fixednumber.ts create mode 100644 src.ts/utils/geturl-browser.ts create mode 100644 src.ts/utils/geturl.ts create mode 100644 src.ts/utils/index.ts create mode 100644 src.ts/utils/logger.ts create mode 100644 src.ts/utils/maths.ts create mode 100644 src.ts/utils/properties.ts create mode 100644 src.ts/utils/rlp-decode.ts create mode 100644 src.ts/utils/rlp-encode.ts create mode 100644 src.ts/utils/rlp.ts create mode 100644 src.ts/utils/storage.ts create mode 100644 src.ts/utils/units.ts create mode 100644 src.ts/utils/utf8.ts create mode 100644 src.ts/wallet/base-wallet.ts create mode 100644 src.ts/wallet/hdwallet.ts create mode 100644 src.ts/wallet/index.ts create mode 100644 src.ts/wallet/json-crowdsale.ts create mode 100644 src.ts/wallet/json-keystore.ts create mode 100644 src.ts/wallet/mnemonic.ts create mode 100644 src.ts/wallet/utils.ts create mode 100644 src.ts/wallet/wallet.ts create mode 100644 src.ts/wordlists/bit-reader.ts create mode 100644 src.ts/wordlists/decode-owl.ts create mode 100644 src.ts/wordlists/decode-owla.ts create mode 100644 src.ts/wordlists/generation/encode-latin.ts create mode 100644 src.ts/wordlists/index.ts create mode 100644 src.ts/wordlists/lang-cz.ts create mode 100644 src.ts/wordlists/lang-en.ts create mode 100644 src.ts/wordlists/lang-es.ts create mode 100644 src.ts/wordlists/lang-fr.ts create mode 100644 src.ts/wordlists/lang-it.ts create mode 100644 src.ts/wordlists/lang-ja.ts create mode 100644 src.ts/wordlists/lang-ko.ts create mode 100644 src.ts/wordlists/lang-pt.ts create mode 100644 src.ts/wordlists/lang-zh.ts create mode 100644 src.ts/wordlists/wordlist-owl.ts create mode 100644 src.ts/wordlists/wordlist-owla.ts create mode 100644 src.ts/wordlists/wordlist.ts create mode 100644 src.ts/wordlists/wordlists-browser.ts create mode 100644 src.ts/wordlists/wordlists-extra.ts create mode 100644 src.ts/wordlists/wordlists.ts create mode 100644 testcases/README.md create mode 100644 testcases/abi.json.gz create mode 100644 testcases/accounts.json.gz create mode 100644 testcases/create.json.gz create mode 100644 testcases/create2.json.gz create mode 100644 testcases/hashes.json.gz create mode 100644 testcases/hmac.json.gz create mode 100644 testcases/mnemonics.json.gz create mode 100644 testcases/namehash.json.gz create mode 100644 testcases/pbkdf.json.gz create mode 100644 testcases/rlp.json.gz create mode 100644 testcases/transaction.json.gz create mode 100644 testcases/transactions.json.gz create mode 100644 testcases/typed-data.json.gz create mode 100644 testcases/wallets.json.gz create mode 100644 testcases/wordlists.json.gz create mode 100644 tsconfig.base.json create mode 100644 tsconfig.commonjs.json create mode 100644 tsconfig.esm.json create mode 100644 tsconfig.types.json diff --git a/.gitignore b/.gitignore new file mode 100644 index 000000000..4eca51f39 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +node_modules/** +output/** +misc/** diff --git a/.npmignore b/.npmignore new file mode 100644 index 000000000..5e2d36c60 --- /dev/null +++ b/.npmignore @@ -0,0 +1,26 @@ + +# Ignore TypeScript config and caches +tsconfig.*.json +tsconfig.tsbuildinfo +rollup.config.js +output/** + +# Ignore admin scripts and files +src.ts/_admin/** +lib.commonjs/_admin/** +lib.esm/_admin/** +types/_admin/** +reporter.cjs +package-commonjs.json + +# Ignore test cases +src.ts/_tests/** +lib.commonjs/_tests/** +lib.esm/_tests/** +types/_tests/** +testcases/** + +# Ignore random junk +.DS_Store +node_modules/** +misc/** diff --git a/package-commonjs.json b/package-commonjs.json new file mode 100644 index 000000000..5bbefffba --- /dev/null +++ b/package-commonjs.json @@ -0,0 +1,3 @@ +{ + "type": "commonjs" +} diff --git a/package.json b/package.json new file mode 100644 index 000000000..535ebb2d5 --- /dev/null +++ b/package.json @@ -0,0 +1,131 @@ +{ + "author": "Richard Moore ", + "dependencies": { + "@noble/hashes": "1.1.2", + "@noble/secp256k1": "1.6.3", + "aes-js": "4.0.0-beta.2", + "tslib": "2.4.0", + "ws": "8.5.0" + }, + "description": "Ethereum library.", + "devDependencies": { + "@rollup/plugin-node-resolve": "13.3.0", + "@types/mocha": "9.1.1", + "c8": "7.12.0", + "mocha": "10.0.0", + "rollup": "2.78.1", + "typescript": "4.7.4", + "uglify-js": "3.17.0" + }, + "engines": { + "node": ">=14.0.0" + }, + "browser": { + "./lib.esm/crypto/crypto.js": "./lib.esm/crypto/crypto-browser.js", + "./lib.esm/providers/provider-ipcsocket.js": "./lib.esm/providers/provider-ipcsocket-browser.js", + "./lib.esm/providers/ws.js": "./lib.esm/providers/ws-browser.js", + "./lib.esm/utils/base64.js": "./lib.esm/utils/base64-browser.js", + "./lib.esm/utils/geturl.js": "./lib.esm/utils/geturl-browser.js", + "./lib.esm/wordlists/wordlists.js": "./lib.esm/wordlists/wordlists-browser.js" + }, + "exports": { + ".": { + "import": "./lib.esm/index.js", + "require": "./lib.commonjs/index.js", + "types": "./types/index.d.ts" + }, + "./abi": { + "import": "./lib.esm/abi/index.js", + "require": "./lib.commonjs/abi/index.js", + "types": "./types/abi/index.d.ts" + }, + "./address": { + "import": "./lib.esm/address/index.js", + "require": "./lib.commonjs/address/index.js", + "types": "./types/address/index.d.ts" + }, + "./constants": { + "import": "./lib.esm/constants/index.js", + "require": "./lib.commonjs/constants/index.js", + "types": "./types/constants/index.d.ts" + }, + "./contract": { + "import": "./lib.esm/contract/index.js", + "require": "./lib.commonjs/contract/index.js", + "types": "./types/contract/index.d.ts" + }, + "./crypto": { + "import": "./lib.esm/crypto/index.js", + "require": "./lib.commonjs/crypto/index.js", + "types": "./types/crypto/index.d.ts" + }, + "./hash": { + "import": "./lib.esm/hash/index.js", + "require": "./lib.commonjs/hash/index.js", + "types": "./types/hash/index.d.ts" + }, + "./providers": { + "import": "./lib.esm/providers/index.js", + "require": "./lib.commonjs/providers/index.js", + "types": "./types/providers/index.d.ts" + }, + "./transaction": { + "import": "./lib.esm/transaction/index.js", + "require": "./lib.commonjs/transaction/index.js", + "types": "./types/transaction/index.d.ts" + }, + "./utils": { + "import": "./lib.esm/utils/index.js", + "require": "./lib.commonjs/utils/index.js", + "types": "./types/utils/index.d.ts" + }, + "./wallet": { + "import": "./lib.esm/wallet/index.js", + "require": "./lib.commonjs/wallet/index.js", + "types": "./types/wallet/index.d.ts" + }, + "./wordlists": { + "import": "./lib.esm/wordlists/index.js", + "require": "./lib.commonjs/wordlists/index.js", + "types": "./types/wordlistsindex.d.ts" + } + }, + "keywords": [ + "ethereum", + "ethers", + "ethersjs" + ], + "license": "MIT", + "main": "./lib.commonjs/index.js", + "module": "./lib.esm/index.js", + "name": "ethers", + "publishConfig": { + "access": "public", + "tag": "beta-exports" + }, + "repository": { + "type": "git", + "url": "git://github.com/ethers-io/ethers.js.git" + }, + "scripts": { + "clean": "rm -rf dist lib.esm lib.commonjs types", + "build": "tsc --project tsconfig.esm.json", + "build-commonjs": "tsc --project tsconfig.commonjs.json && cp ./package-commonjs.json ./lib.commonjs/package.json", + "build-types": "tsc --project tsconfig.types.json", + "build-docs": "echo 'foo'", + "auto-build": "npm run build -- -w", + "build-all": "npm run build && npm run build-commonjs && npm run build-types", + "build-clean": "npm run clean && npm run build-all", + "_dist-stats": "gzip -k9f -S '.gz' ./dist/ethers.min.js && gzip -k9f -S '.gz' ./dist/wordlists-extra.min.js && du -hs ./dist/*.gz && echo '' && du -hs ./dist/*.js", + "_build-dist": "rollup -c && uglifyjs ./dist/ethers.js -o ./dist/ethers.min.js && uglifyjs ./dist/wordlists-extra.js -o ./dist/wordlists-extra.min.js && npm run _dist-stats", + "build-dist": "npm run build && npm run _build-dist", + "stats": "echo 'Dependencies' && npm ls --all --omit=dev", + "test": "mocha --reporter ./reporter.cjs ./lib.esm/_tests/test-*.js", + "test-commonjs": "mocha --reporter ./reporter.cjs ./lib.commonjs/_tests/test-*.js", + "test-coverage": "c8 -o output -r lcov -r text mocha --no-color --reporter ./reporter.cjs ./lib.esm/_tests/test-*.js | tee output/summary.txt" + }, + "sideEffects": false, + "type": "module", + "types": "./types/index.d.ts", + "version": "6.0.0-beta-exports.0" +} diff --git a/reporter.cjs b/reporter.cjs new file mode 100644 index 000000000..14d579ab8 --- /dev/null +++ b/reporter.cjs @@ -0,0 +1,213 @@ +'use strict'; + +const Mocha = require('mocha'); +const { + EVENT_RUN_BEGIN, + EVENT_RUN_END, + EVENT_TEST_BEGIN, + EVENT_TEST_END, + EVENT_TEST_FAIL, + EVENT_TEST_PASS, + EVENT_SUITE_BEGIN, + EVENT_SUITE_END +} = Mocha.Runner.constants; + + +// See: https://stackoverflow.com/questions/9781218/how-to-change-node-jss-console-font-color +let disableColor = false; //!(process.stdout.isTTY); +process.argv.forEach((arg) => { + if (arg === "--no-color") { disableColor = true; } +}); + +const Colors = { + "blue": "\x1b[0;34m", + "blue+": "\x1b[0;1;34m", + "cyan": "\x1b[0;36m", + "cyan+": "\x1b[0;1;36m", + "green": "\x1b[0;32m", + "green+": "\x1b[0;1;32m", + "magenta-": "\x1b[0;2;35m", + "magenta": "\x1b[0;35m", + "magenta+": "\x1b[0;1;35m", + "red": "\x1b[0;31m", + "red+": "\x1b[0;1;31m", + "yellow": "\x1b[0;33m", + "yellow+": "\x1b[0;1;33m", + "dim": "\x1b[0;2;37m", + "bold": "\x1b[0;1;37m", + "normal": "\x1b[0m" +}; + +function colorify(text) { + return unescapeColor(text.replace(/(<([a-z+]+)>)/g, (all, _, color) => { + if (disableColor) { return ""; } + + const seq = Colors[color]; + if (seq == null) { + console.log("UNKNOWN COLOR:", color); + return ""; + } + return seq; + })) + Colors.normal; +} + +function escapeColor(text) { + return text.replace(/&/g, "&").replace(//g, ">"); +} + +function unescapeColor(text) { + return text.replace(/>/g, ">").replace(/</g, "<").replace(/&/g, "&"); +} + +function getString(value) { + if (value instanceof Error) { + return value.stack; + } + return String(value); +} + +// To prevent environments from thinking we're dead due to lack of +// output, we force output after 20s +function getTime() { return (new Date()).getTime(); } +const KEEP_ALIVE = 20 * 1000; + +// this reporter outputs test results, indenting two spaces per suite +class MyReporter { + constructor(runner) { + this._errors = [ ]; + this._indents = 1; + this._lastLog = getTime(); + this._lastPass = ""; + this._lastPrefix = null; + this._lastPrefixHeader = null; + this._testLogs = [ ]; + this._suiteLogs = [ ]; + this._prefixCount = 0; + const stats = runner.stats; + + runner.once(EVENT_RUN_BEGIN, () => { + + }).on(EVENT_SUITE_BEGIN, (suite) => { + this._suiteLogs.push([ ]); + suite._ethersLog = (text) => { + this._suiteLogs[this._suiteLogs.length - 1].push(getString(text)) + }; + if (suite.title.trim()) { + this.log(`Suite: ${ escapeColor(suite.title) }`) + } + this.increaseIndent(); + + }).on(EVENT_SUITE_END, (suite) => { + this.flush(true); + this.decreaseIndent(); + const logs = this._suiteLogs.pop(); + if (logs.length) { + logs.join("\n").split("\n").forEach((line) => { + this.log(` >> ${ escapeColor(line) }`); + }); + } + if (suite.title.trim()) { this.log(""); } + + }).on(EVENT_TEST_BEGIN, (test) => { + this._testLogs.push([ ]); + test._ethersLog = (text) => { + this._testLogs[this._testLogs.length - 1].push(getString(text)) + }; + + }).on(EVENT_TEST_END, (test) => { + const logs = this._testLogs.pop(); + if (logs.length) { + this.flush(false); + logs.join("\n").split("\n").forEach((line) => { + this.log(` >> ${ escapeColor(line) }`); + }); + } + + }).on(EVENT_TEST_PASS, (test) => { + this.addPass(test.title); + + }).on(EVENT_TEST_FAIL, (test, error) => { + this.flush(); + this._errors.push({ test, error }); + this.log( + ` [ fail(${ this._errors.length }): ${ escapeColor(test.title) } - ${ escapeColor(error.message) } ]` + ); + + }).once(EVENT_RUN_END, () => { + this.flush(true); + this.indent = 0; + + if (this._errors.length) { + this._errors.forEach(({ test, error }, index) => { + this.log("---------------------"); + this.log(`ERROR ${ index + 1 }: ${ escapeColor(test.title) }`); + this.log(escapeColor(error.toString())); + }); + this.log("====================="); + } + + const { duration, passes, failures } = stats; + const total = passes + failures; + this.log(`Done: ${ passes }/${ total } passed (${ failures } failed)`); + }); + } + + log(line) { + this._lastLog = getTime(); + const indent = Array(this._indents).join(' '); + console.log(`${ indent }${ colorify(line) }`); + } + + addPass(line) { + const prefix = line.split(":")[0]; + if (prefix === this._lastPrefix) { + this._prefixCount++; + if (getTime() - this._lastLog > KEEP_ALIVE) { + const didLog = this.flush(false); + // Nothing was output, so show *something* so the + // environment knows we're still alive and kicking + if (!didLog) { + this.log(" [ keep-alive; forced output ]") + } + } + } else { + this.flush(true); + this._lastPrefixHeader = null; + this._lastPrefix = prefix; + this._prefixCount = 1; + } + this._lastLine = line; + } + + flush(reset) { + let didLog = false; + if (this._lastPrefix != null) { + if (this._prefixCount === 1 && this._lastPrefixHeader == null) { + this.log(escapeColor(this._lastLine)); + didLog = true; + } else if (this._prefixCount > 0) { + if (this._lastPrefixHeader !== this._lastPrefix) { + this.log(`${ escapeColor(this._lastPrefix) }:`); + this._lastPrefixHeader = this._lastPrefix; + } + this.log(` - ${ this._prefixCount } tests passed (prefix coalesced)`); + didLog = true; + } + } + + if (reset) { + this._lastPrefixHeader = null; + this._lastPrefix = null; + } + + this._prefixCount = 0; + + return didLog; + } + + increaseIndent() { this._indents++; } + + decreaseIndent() { this._indents--; } +} + +module.exports = MyReporter; diff --git a/rollup.config.js b/rollup.config.js new file mode 100644 index 000000000..e71e63ed1 --- /dev/null +++ b/rollup.config.js @@ -0,0 +1,47 @@ + +import { nodeResolve } from '@rollup/plugin-node-resolve'; + +function getConfig(opts) { + if (opts == null) { opts = { }; } + + const file = `./dist/ethers${ (opts.suffix || "") }.js`; + const exportConditions = [ "default", "module", "import" ]; + const mainFields = [ "module", "main" ]; + if (opts.browser) { mainFields.unshift("browser"); } + + return { + input: "./lib.esm/index.js", + output: { + file, + format: "esm", + sourcemap: true + }, + treeshake: false, + plugins: [ nodeResolve({ + exportConditions, + mainFields, + modulesOnly: true, + preferBuiltins: false + }) ], +// external: [ "crypto" ] + }; +} + +export default [ + getConfig({ browser: true }), + { + input: "./lib.esm/wordlists/wordlists-extra.js", + output: { + file: "./dist/wordlists-extra.js", + format: "esm", + sourcemap: true + }, + treeshake: true, + plugins: [ nodeResolve({ + exportConditions: [ "default", "module", "import" ], + mainFields: [ "browser", "module", "main" ], + modulesOnly: true, + preferBuiltins: false + }) ], + } +]; diff --git a/src.ts/_admin/update-version-const.ts b/src.ts/_admin/update-version-const.ts new file mode 100644 index 000000000..3b1f73350 --- /dev/null +++ b/src.ts/_admin/update-version-const.ts @@ -0,0 +1,8 @@ +import { atomicWrite } from "./utils/fs.js"; +import { resolve } from "./utils/path.js"; +import { loadJson } from "./utils/json.js"; + +const version = loadJson(resolve("package.json")).version; + +const content = `export const version = "${ version }";\n`; +atomicWrite(resolve("src.ts/_version.ts"), content); diff --git a/src.ts/_admin/utils/fs.ts b/src.ts/_admin/utils/fs.ts new file mode 100644 index 000000000..692ba12f6 --- /dev/null +++ b/src.ts/_admin/utils/fs.ts @@ -0,0 +1,9 @@ +import fs from "fs"; + +import { resolve } from "./path.js"; + +export function atomicWrite(path: string, value: string | Uint8Array): void { + const tmp = resolve(".atomic-tmp"); + fs.writeFileSync(tmp, value); + fs.renameSync(tmp, path); +} diff --git a/src.ts/_admin/utils/json.ts b/src.ts/_admin/utils/json.ts new file mode 100644 index 000000000..a21251afd --- /dev/null +++ b/src.ts/_admin/utils/json.ts @@ -0,0 +1,32 @@ +import fs from "fs"; + +import { atomicWrite } from "./fs.js"; + + +export function loadJson(path: string): any { + return JSON.parse(fs.readFileSync(path).toString()); +} + +type Replacer = (key: string, value: any) => any; + +export function saveJson(filename: string, data: any, sort?: boolean): any { + + let replacer: (Replacer | undefined) = undefined; + if (sort) { + replacer = (key, value) => { + if (Array.isArray(value)) { + // pass + } else if (value && typeof(value) === "object") { + const keys = Object.keys(value); + keys.sort(); + return keys.reduce((accum, key) => { + accum[key] = value[key]; + return accum; + }, >{}); + } + return value; + }; + } + + atomicWrite(filename, JSON.stringify(data, replacer, 2) + "\n"); +} diff --git a/src.ts/_admin/utils/path.ts b/src.ts/_admin/utils/path.ts new file mode 100644 index 000000000..b81eeba8c --- /dev/null +++ b/src.ts/_admin/utils/path.ts @@ -0,0 +1,14 @@ +import { dirname, resolve as _resolve } from "path"; +import { fileURLToPath } from 'url'; + +const __filename = fileURLToPath(import.meta.url); +const __dirname = dirname(__filename); + +export const ROOT = _resolve(__dirname, "../../../"); +console.log(ROOT); + +export function resolve(...args: Array): string { + args = args.slice(); + args.unshift(ROOT); + return _resolve.apply(null, args); +} diff --git a/src.ts/_tests/test-abi.ts b/src.ts/_tests/test-abi.ts new file mode 100644 index 000000000..f92bc8f80 --- /dev/null +++ b/src.ts/_tests/test-abi.ts @@ -0,0 +1,43 @@ +import assert from "assert"; +import { loadTests } from "./utils.js"; + +import { TestCaseAbi, TestCaseAbiVerbose } from "./types.js"; + +import { defaultAbiCoder } from "../index.js"; + +function equal(actual: any, expected: TestCaseAbiVerbose): void { + switch (expected.type) { + case "address": case "boolean": case "hexstring": case "string": + assert.equal(actual, expected.value); + return; + case "number": + assert.equal(actual, BigInt(expected.value)); + return + case "array": case "object": + assert.ok(Array.isArray(actual), "!array"); + assert.equal(actual.length, expected.value.length, ".length mismatch"); + for (let i = 0; i < actual.length; i++) { + equal(actual[i], expected.value[i]); + } + return; + } + throw new Error(`unsupported: ${ expected }`); +} + +describe("Tests ABI Coder", function() { + const tests = loadTests("abi"); + + for (const test of tests) { + it(`tests ABI encoding: (${ test.name })`, function() { + const encoded = defaultAbiCoder.encode([ test.type ], [ test.value ]); + assert.equal(encoded, test.encoded, "encoded"); + }); + } + + for (const test of tests) { + it(`tests ABI decoding: (${ test.name })`, function() { + const decoded = defaultAbiCoder.decode([ test.type ], test.encoded)[0]; + equal(decoded, test.verbose); + }); + } +}); diff --git a/src.ts/_tests/test-address.ts b/src.ts/_tests/test-address.ts new file mode 100644 index 000000000..373d91544 --- /dev/null +++ b/src.ts/_tests/test-address.ts @@ -0,0 +1,132 @@ +import assert from "assert"; + +import { loadTests } from "./utils.js"; + +import type { + TestCaseAccount, + TestCaseCreate, + TestCaseCreate2 +} from "./types.js"; + +import { + getAddress, getIcapAddress, + getCreateAddress, getCreate2Address +} from "../index.js"; + + +describe("computes checksum address", function() { + const tests = loadTests("accounts"); + for (const test of tests) { + it(`computes the checksum address: ${ test.name }`, function() { + assert.equal(getAddress(test.address), test.address); + assert.equal(getAddress(test.icap), test.address); + assert.equal(getAddress(test.address.substring(2)), test.address); + assert.equal(getAddress(test.address.toLowerCase()), test.address); + assert.equal(getAddress("0x" + test.address.substring(2).toUpperCase()), test.address); + }); + } + + const invalidAddresses: Array<{ name: string, value: any }> = [ + { name: "null", value: null }, + { name: "number", value: 1234 }, + { name: "emtpy bytes", value: "0x" }, + { name: "too short", value: "0x8ba1f109551bd432803012645ac136ddd64dba" }, + { name: "too long", value: "0x8ba1f109551bd432803012645ac136ddd64dba7200" }, + ]; + + invalidAddresses.forEach(({ name, value }) => { + it(`fails on invalid address: ${ name }`, function() { + assert.throws(function() { + getAddress(value); + }, function(error: any) { + return (error.code === "INVALID_ARGUMENT" && + error.message.match(/^invalid address/) && + error.argument === "address" && + error.value === value); + }); + }); + }); + + it("fails on invalid checksum", function() { + const value = "0x8ba1f109551bD432803012645Ac136ddd64DBa72" + assert.throws(function() { + getAddress(value); + }, function(error: any) { + return (error.code === "INVALID_ARGUMENT" && + error.message.match(/^bad address checksum/) && + error.argument === "address" && + error.value === value); + }); + }); + + it("fails on invalid IBAN checksum", function() { + const value = "XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK37"; + assert.throws(function() { + getAddress(value); + }, function(error: any) { + return (error.code === "INVALID_ARGUMENT" && + error.message.match(/^bad icap checksum/) && + error.argument === "address" && + error.value === value); + }); + }); +}); + +describe("computes ICAP address", function() { + const tests = loadTests("accounts"); + for (const test of tests) { + it(`computes the ICAP address: ${ test.name }`, function() { + assert.equal(getIcapAddress(test.address), test.icap); + assert.equal(getAddress(test.address.toLowerCase()), test.address); + assert.equal(getAddress("0x" + test.address.substring(2).toUpperCase()), test.address); + }); + } +}); + +describe("computes create address", function() { + const tests = loadTests("create"); + for (const { sender, creates } of tests) { + for (const { name, nonce, address } of creates) { + it(`computes the create address: ${ name }`, function() { + assert.equal(getCreateAddress({ from: sender, nonce }), address); + }); + } + } +}); + +describe("computes create2 address", function() { + const tests = loadTests("create2"); + for (const { sender, creates } of tests) { + for (const { name, salt, initCodeHash, address } of creates) { + it(`computes the create2 address: ${ name }`, function() { + assert.equal(getCreate2Address(sender, salt, initCodeHash), address); + }); + } + } + + const sender = "0x8ba1f109551bD432803012645Ac136ddd64DBA72"; + const salt = "0x1c8aff950685c2ed4bc3174f3472287b56d9517b9c948127319a09a7a36deac8"; + const initCodeHash = "0x8452c9b9140222b08593a26daa782707297be9f7b3e8281d7b4974769f19afd0"; + + it("fails on invalid salt", function() { + const badSalt = "0x1c8aff950685c2ed4bc3174f3472287b56d9517b9c948127319a09a7a36dea"; + assert.throws(function() { + getCreate2Address(sender, badSalt, initCodeHash); + }, function(error: any) { + return (error.code === "INVALID_ARGUMENT" && + error.argument === "salt" && + error.value === badSalt); + }); + }); + + it("fails on invalid initCodeHash", function() { + const badInitCodeHash = "0x8452c9b9140222b08593a26daa782707297be9f7b3e8281d7b4974769f19af"; + assert.throws(function() { + getCreate2Address(sender, salt, badInitCodeHash); + }, function(error: any) { + return (error.code === "INVALID_ARGUMENT" && + error.argument === "initCodeHash" && + error.value === badInitCodeHash); + }); + }); +}); diff --git a/src.ts/_tests/test-contract.ts b/src.ts/_tests/test-contract.ts new file mode 100644 index 000000000..c1062129e --- /dev/null +++ b/src.ts/_tests/test-contract.ts @@ -0,0 +1,99 @@ +/* +import { Typed } from "../abi/index.js"; +import * as providers from "../providers/index.js"; + +import { Contract } from "../index.js"; + +import { log } from "./utils.js"; +*/ +//import type { Addressable } from "@ethersproject/address"; +//import type { BigNumberish } from "@ethersproject/logger"; + +/* +import type { + ConstantContractMethod, ContractMethod, ContractEvent +} from "../index.js"; +*/ + +// @TODO +/* +describe("Test Contract Calls", function() { + it("finds typed methods", async function() { + const contract = new Contract("0xC18360217D8F7Ab5e7c516566761Ea12Ce7F9D72", [ + "function foo(string s) view returns (uint)", + "function foo(uint8) view returns (uint)", + "function foo(uint u, bool b) view returns (uint)", + ]); + const value = Typed.string("42"); + await contract.foo.populateTransaction(value, Typed.overrides({ value: 100 })) + contract["foo(string)"].fragment + }); +}); +*/ +/* +describe("Test Contract Interface", function() { + it("builds contract interfaces", async function() { + this.timeout(60000); + + interface Erc20Interface { + // Constant Methods + balanceOf: ConstantContractMethod<[ address: string | Addressable ], bigint>; + decimals: ConstantContractMethod<[ ], bigint>; + + name: ConstantContractMethod<[ ], string>; + symbol: ConstantContractMethod<[ ], string>; + + // Mutation Methods + transferFrom: ContractMethod<[ address: string | Addressable, + address: string | Addressable, amount: BigNumberish ], boolean>; + + // Events + filters: { + Transfer: ContractEvent<[ from: Addressable | string, to: BigNumberish ]>; + } + } + + const erc20Abi = [ + "function balanceOf(address owner) view returns (uint)", + "function decimals() view returns (uint)", + "function name() view returns (string)", + "function symbol() view returns (string)", + + "function transferFrom(address from, address to, uint amount) returns (boolean)", + + "event Transfer(address indexed from, address indexed to, uint amount)" + ]; + + class Erc20Contract extends BaseContract.buildClass(erc20Abi) { }; + + const provider = new providers.InfuraProvider(); + // ENS + //const addr = "0xC18360217D8F7Ab5e7c516566761Ea12Ce7F9D72"; + // DAI + const addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F"; + const contract = new Erc20Contract(addr, provider); + console.log("SYMBOL", await contract.symbol()); + console.log("DECIMALS", await contract.decimals()); + console.log(await contract.balanceOf("0x5555763613a12D8F3e73be831DFf8598089d3dCa")); + console.log(await contract.balanceOf("ricmoo.eth")); + + await contract.on(contract.filters.Transfer, (from, to, value, event) => { + console.log("HELLO!", { from, to, value, event }); + event.removeListener(); + }); + const logs = await contract.queryFilter("Transfer", -10); + console.log(logs, logs[0], logs[0].args.from); + }); +}); +*/ +/* +describe("Test Contract Calls", function() { + it("calls ERC-20 methods", async function() { + const provider = new providers.AnkrProvider(); + const contract = new Contract("0xC18360217D8F7Ab5e7c516566761Ea12Ce7F9D72", [ + "function balanceOf(address owner) view returns (uint)", + ], provider); + log(this, `balance: ${ await contract.balanceOf("0x5555763613a12D8F3e73be831DFf8598089d3dCa") }`); + }); +}); +*/ diff --git a/src.ts/_tests/test-crypto-algoswap.ts b/src.ts/_tests/test-crypto-algoswap.ts new file mode 100644 index 000000000..de7837a92 --- /dev/null +++ b/src.ts/_tests/test-crypto-algoswap.ts @@ -0,0 +1,116 @@ +import assert from "assert"; + +import { + lock, + + computeHmac, + + keccak256, ripemd160, sha256, sha512, + + pbkdf2, scrypt, scryptSync +} from "../index.js"; + +interface Algorithm { + (...args: Array): string | Promise; + + register: (func: any) => void; + lock: () => void; + _: (...args: Array) => any; +} + +interface TestCase { + name: string; + params: Array; + algorithm: Algorithm; + hijackTag: string; +} + + +describe("test registration", function() { + + let hijack = ""; + function getHijack(algo: string) { + return function(...args: Array) { + hijack = `hijacked ${ algo }: ${ JSON.stringify(args) }`; + return "0x42"; + } + } + + const tests: Array = [ + { + name: "keccak256", + params: [ "0x" ], + hijackTag: 'hijacked keccak256: [{}]', + algorithm: keccak256 + }, + { + name: "sha256", + params: [ "0x" ], + hijackTag: 'hijacked sha256: [{}]', + algorithm: sha256 + }, + { + name: "sha512", + params: [ "0x" ], + hijackTag: 'hijacked sha512: [{}]', + algorithm: sha512 + }, + { + name: "ripemd160", + params: [ "0x" ], + hijackTag: 'hijacked ripemd160: [{}]', + algorithm: ripemd160 + }, + { + name: "pbkdf2", + params: [ "0x", "0x", 1024, 32, "sha256" ], + hijackTag: 'hijacked pbkdf2: [{},{},1024,32,"sha256"]', + algorithm: pbkdf2 + }, + { + name: "scryptSync", + params: [ "0x", "0x", 1024, 8, 1, 32 ], + hijackTag: 'hijacked scryptSync: [{},{},1024,8,1,32]', + algorithm: scryptSync + }, + { + name: "scrypt", + params: [ "0x", "0x", 1024, 8, 1, 32 ], + hijackTag: 'hijacked scrypt: [{},{},1024,8,1,32,null]', + algorithm: scrypt + }, + { + name: "computeHmac", + params: [ "sha256", "0x", "0x" ], + hijackTag: 'hijacked computeHmac: ["sha256",{},{}]', + algorithm: computeHmac + }, + ]; + + tests.forEach(({ name, params, hijackTag, algorithm }) => { + it(`swaps in hijacked callback: ${ name }`, async function() { + const initial = await algorithm(...params); + + algorithm.register(getHijack(name)); + + assert.equal(await algorithm(...params), "0x42"); + assert.equal(hijack, hijackTag); + + algorithm.register(algorithm._); + assert.equal(await algorithm(...params), initial); + }); + }); + + it("prevents swapping after locked", function() { + lock(); + + tests.forEach(({ name, params, hijackTag, algorithm }) => { + assert.throws(function() { + algorithm.register(getHijack("test")); + }, function(error: any) { + return (error.message === `${ name } is locked`); + }); + }); + }); + +}); diff --git a/src.ts/_tests/test-crypto.ts b/src.ts/_tests/test-crypto.ts new file mode 100644 index 000000000..b8b1b17aa --- /dev/null +++ b/src.ts/_tests/test-crypto.ts @@ -0,0 +1,238 @@ +import assert from "assert"; + +import { loadTests } from "./utils.js"; + +import type { TestCaseHash, TestCaseHmac, TestCasePbkdf } from "./types.js"; + +import { + computeHmac, + keccak256, ripemd160, sha256, sha512, + pbkdf2, scrypt, scryptSync +} from "../index.js"; + + +describe("test hashing", function() { + const tests = loadTests("hashes"); + + tests.forEach((test) => { + it(`computes sha2-256: ${ test.name }`, function() { + assert.equal(sha256(test.data), test.sha256); + }); + }); + + tests.forEach((test) => { + it(`computes sha2-512: ${ test.name }`, function() { + assert.equal(sha512(test.data), test.sha512); + }); + }); + + tests.forEach((test) => { + it(`computes ripemd160: ${ test.name }`, function() { + assert.equal(ripemd160(test.data), test.ripemd160); + }); + }); + + tests.forEach((test) => { + it(`computes keccak256: ${ test.name }`, function() { + assert.equal(keccak256(test.data), test.keccak256); + }); + }); +}); + +describe("test password-based key derivation", function() { + const tests = loadTests("pbkdf"); + + tests.forEach((test) => { + it(`computes pbkdf2: ${ test.name}`, function() { + const password = Buffer.from(test.password.substring(2), "hex"); + const salt = Buffer.from(test.salt.substring(2), "hex"); + const { iterations, algorithm, key } = test.pbkdf2; + const result = pbkdf2(password, salt, iterations, test.dkLen, algorithm); + assert.equal(result, key); + }); + }); + + tests.forEach((test) => { + it(`computes scrypt (sync): ${ test.name}`, function() { + this.timeout(1000); + + const password = Buffer.from(test.password.substring(2), "hex"); + const salt = Buffer.from(test.salt.substring(2), "hex"); + const { N, r, p, key } = test.scrypt; + const result = scryptSync(password, salt, N, r, p, test.dkLen); + assert.equal(result, key); + }); + }); + + tests.forEach((test) => { + it(`computes scrypt (async): ${ test.name}`, async function() { + this.timeout(1000); + + const password = Buffer.from(test.password.substring(2), "hex"); + const salt = Buffer.from(test.salt.substring(2), "hex"); + const { N, r, p, key } = test.scrypt; + + let progressCount = 0, progressOk = true, lastProgress = -1; + + const result = await scrypt(password, salt, N, r, p, test.dkLen, (progress) => { + if (progress < lastProgress) { progressOk = false; } + lastProgress = progress; + progressCount++; + }); + + assert.ok(progressOk, "progress was not monotonically increasing"); + assert.ok(progressCount > 100, "progress callback was called at leat 100 times"); + assert.equal(result, key); + }); + }); + +}); + +describe("test hmac", function() { + const tests = loadTests("hmac"); + + tests.forEach((test) => { + it(`computes hmac: ${ test.name}`, async function() { + const { algorithm, key, data } = test; + assert.equal(computeHmac(algorithm, key, data), test.hmac); + }); + }); +}); + +/* +describe("test registration", function() { + let hijack = ""; + function getHijack(algo: string) { + return function(...args: Array) { + hijack = `hijacked ${ algo }: ${ JSON.stringify(args) }`; + return "0x42"; + } + } + + it("hijacks keccak256", function() { + const initial = keccak256("0x"); + + keccak256.register(getHijack("kecak256")); + assert.equal(keccak256("0x"), "0x42"); + assert.equal(hijack, 'hijacked kecak256: [{}]'); + + keccak256.register(keccak256._); + assert.equal(keccak256("0x"), initial); + + keccak256.lock(); + + assert.throws(function() { + keccak256.register(getHijack("test")); + }, function(error) { + return (error.message === "keccak256 is locked"); + }); + }); + + it("hijacks sha256", function() { + const initial = sha256("0x"); + + sha256.register(getHijack("sha256")); + assert.equal(sha256("0x"), "0x42"); + assert.equal(hijack, 'hijacked sha256: [{}]'); + + sha256.register(sha256._); + assert.equal(sha256("0x"), initial); + + sha256.lock(); + + assert.throws(function() { + sha256.register(getHijack("test")); + }, function(error) { + return (error.message === "sha256 is locked"); + }); + }); + + it("hijacks sha512", function() { + const initial = sha512("0x"); + + sha512.register(getHijack("sha512")); + assert.equal(sha512("0x"), "0x42"); + assert.equal(hijack, 'hijacked sha512: [{}]'); + + sha512.register(sha512._); + assert.equal(sha512("0x"), initial); + + sha512.lock(); + + assert.throws(function() { + sha512.register(getHijack("test")); + }, function(error) { + return (error.message === "sha512 is locked"); + }); + }); + + it("hijacks pbkdf2", function() { + const initial = pbkdf2("0x", "0x", 1024, 32, "sha256"); + + pbkdf2.register(getHijack("pbkdf2")); + assert.equal(pbkdf2("0x", "0x", 1024, 32, "sha256"), "0x42"); + assert.equal(hijack, 'hijacked pbkdf2: [{},{},1024,32,"sha256"]'); + + pbkdf2.register(pbkdf2._); + assert.equal(pbkdf2("0x", "0x", 1024, 32, "sha256"), initial); + + pbkdf2.lock(); + + assert.throws(function() { + pbkdf2.register(getHijack("test")); + }, function(error) { + return (error.message === "pbkdf2 is locked"); + }); + }); + + it("hijacks scryptSync", function() { + + function getHijack(...args: Array) { + hijack = `hijacked scryptSync: ${ JSON.stringify(args) }`; + return new Uint8Array([ 0x42 ]); + } + + const initial = scryptSync("0x", "0x", 1024, 8, 1, 32); + + scryptSync.register(getHijack); + assert.equal(scryptSync("0x", "0x", 1024, 8, 1, 32), "0x42"); + assert.equal(hijack, 'hijacked scryptSync: [{},{},1024,8,1,32]'); + + scryptSync.register(scryptSync._); + assert.equal(scryptSync("0x", "0x", 1024, 8, 1, 32), initial); + + scryptSync.lock(); + + assert.throws(function() { + scryptSync.register(getHijack); + }, function(error) { + return (error.message === "scryptSync is locked"); + }); + }); + + it("hijacks scrypt", async function() { + function getHijack(...args: Array) { + hijack = `hijacked scrypt: ${ JSON.stringify(args) }`; + return Promise.resolve(new Uint8Array([ 0x42 ])); + } + + const initial = await scrypt("0x", "0x", 1024, 8, 1, 32); + + scrypt.register(getHijack); + assert.equal(await scrypt("0x", "0x", 1024, 8, 1, 32), "0x42"); + assert.equal(hijack, 'hijacked scrypt: [{},{},1024,8,1,32,null]'); + + scrypt.register(scrypt._); + assert.equal(await scrypt("0x", "0x", 1024, 8, 1, 32), initial); + + scrypt.lock(); + + assert.throws(function() { + scrypt.register(getHijack); + }, function(error) { + return (error.message === "scrypt is locked"); + }); + }); + +}); +*/ diff --git a/src.ts/_tests/test-hash-typeddata.ts b/src.ts/_tests/test-hash-typeddata.ts new file mode 100644 index 000000000..bf9a6ab50 --- /dev/null +++ b/src.ts/_tests/test-hash-typeddata.ts @@ -0,0 +1,20 @@ +import assert from "assert"; +import { loadTests } from "./utils.js"; +import type { TestCaseTypedData } from "./types.js"; + +import { TypedDataEncoder } from "../index.js"; + + +describe("Tests Typed Data (EIP-712)", function() { + const tests = loadTests("typed-data"); + for (const test of tests) { + it(`tests encoding typed-data: ${ test.name }`, function() { + const encoder = TypedDataEncoder.from(test.types); + assert.equal(encoder.primaryType, test.primaryType, "primaryType"); + assert.equal(encoder.encode(test.data), test.encoded, "encoded"); + + assert.equal(TypedDataEncoder.getPrimaryType(test.types), test.primaryType, "primaryType"); + assert.equal(TypedDataEncoder.hash(test.domain, test.types, test.data), test.digest, "digest"); + }); + } +}); diff --git a/src.ts/_tests/test-hash.ts b/src.ts/_tests/test-hash.ts new file mode 100644 index 000000000..f8e4d314d --- /dev/null +++ b/src.ts/_tests/test-hash.ts @@ -0,0 +1,110 @@ +/* +import assert from "assert"; +import { loadTests } from "./utils.js" +import type { TestCaseNamehash } from "./types.js"; + +import { dnsEncode, isValidName, namehash } from "../index.js"; + +describe("Tests Namehash", function() { + const tests = loadTests("namehash"); + for (const test of tests) { + it(`hashes ENS names: ${ JSON.stringify(test.ensName) }`, function() { + const actual = namehash(test.ensName); + + assert.equal(actual, test.namehash, "namehash"); + + // The empty string is not a valid ENS name + if (test.ensName) { + assert.ok(isValidName(test.ensName), "isValidName"); + } + }); + } +}); + +describe("Tests Bad ENS Names", function() { + const badTests: Array<{ ensName: any, prefix: string }> = [ + { ensName: ".", prefix: "missing component" }, + { ensName:"..", prefix: "missing component" }, + { ensName:"ricmoo..eth", prefix: "missing component" }, + { ensName:"ricmoo...eth", prefix: "missing component" }, + { ensName:".foo", prefix: "missing component" }, + { ensName:"foo.", prefix: "missing component" }, + { ensName: 1234, prefix: "not a string" }, + { ensName: true, prefix: "not a string" }, + ]; + + // The empty string is not a valid name, but has a valid namehash + // (the zero hash) as it is the base case for recursion + it("empty ENS name", function() { + assert.ok(!isValidName(""), "!isValidName"); + }); + + for (const { ensName, prefix } of badTests) { + it(`fails on bad ENS name: ${ JSON.stringify(ensName) }`, function() { + assert.ok(!isValidName(ensName), "!isValidName"); + assert.throws(() => { + const result = namehash(ensName); + console.log(result); + }, (error) => { + const errorPrefix = `invalid ENS name; ${ prefix }`; + return (error.code === "INVALID_ARGUMENT" && + error.argument === "name" && error.value === ensName && + error.message.substring(0, errorPrefix.length) === errorPrefix); + }); + }); + } +}); + +describe("Tests DNS Encoding", function() { + const tests: Array<{ ensName: string, dnsEncoded: string}> = [ + { ensName: "", dnsEncoded: "0x00" }, + { ensName: "ricmoo.eth", dnsEncoded: "0x067269636d6f6f0365746800" }, + ]; + + for (const { ensName, dnsEncoded } of tests) { + it(`computes the DNS Encoding: ${ JSON.stringify(ensName) }`, function() { + assert.equal(dnsEncode(ensName), dnsEncoded, "dnsEncoded"); + }); + } +}); + +describe("Tests DNS Names", function() { + const badTests: Array<{ ensName: any, prefix: string}> = [ + { ensName: ".", prefix: "invalid DNS name; missing component" }, + { ensName: "foo..bar", prefix: "invalid DNS name; missing component" }, + { ensName: ".foo", prefix: "invalid DNS name; missing component" }, + { ensName: "foo.", prefix: "invalid DNS name; missing component" }, + { ensName: 1234, prefix: "invalid DNS name; not a string" }, + { ensName: true, prefix: "invalid DNS name; not a string" }, + ]; + + for (const { ensName, prefix } of badTests) { + it(`fails on bad DNS name: ${ JSON.stringify(ensName) }`, function() { + assert.throws(() => { + const result = dnsEncode(ensName); + console.log(result); + }, (error) => { + return (error.code === "INVALID_ARGUMENT" && + error.argument === "name" && error.value === ensName && + error.message.substring(0, prefix.length) === prefix); + }); + }); + } + + { + const ensName = "foobar012345678901234567890123456789012345678901234567890123456789"; + const prefix = "too long"; + it(`fails on bad DNS name: ${ JSON.stringify(ensName) }`, function() { + assert.throws(() => { + const result = dnsEncode(ensName); + console.log(result); + }, (error) => { + return (error.code === "INVALID_ARGUMENT" && + error.argument === "value" && error.value === ensName && + error.message.substring(0, prefix.length) === prefix); + }); + }); + } + +}); +*/ diff --git a/src.ts/_tests/test-rlp.ts b/src.ts/_tests/test-rlp.ts new file mode 100644 index 000000000..b1fb7e49d --- /dev/null +++ b/src.ts/_tests/test-rlp.ts @@ -0,0 +1,101 @@ +import assert from "assert"; + +import { loadTests } from "./utils.js"; + +import { decodeRlp, encodeRlp } from "../index.js"; + +import type { TestCaseRlp } from "./types.js"; + +describe("Test RLP Coder", function() { + + const tests = loadTests("rlp"); + + tests.forEach(({ name, encoded, decoded }) => { + it(`encodes RLP: ${ name }`, function() { + assert.equal(encodeRlp(decoded), encoded); + }); + }); + + tests.forEach(({ name, encoded, decoded }) => { + it(`decodes RLP: ${ name }`, function() { + assert.deepStrictEqual(decodeRlp(encoded), decoded); + }); + }); +}); + +describe("Test bad RLP Data", function() { + it("fails encoding data with invalid values", function() { + assert.throws(() => { + encodeRlp([ "0x1234", 1234 ]); + }, (error: any) => { + return (error.code === "INVALID_ARGUMENT" && + error.argument === "object" && + error.value === 1234) + }); + }); + + it("fails decoding data with trailing junk", function() { + assert.throws(() => { + // Zeros_1 + decodeRlp("0x0042"); + }, (error: any) => { + return (error.code === "INVALID_ARGUMENT" && + error.message.match(/^unexpected junk after rlp payload/) && + error.argument === "data" && + error.value === "0x0042") + }); + }); + + it ("fails decoding short data", function() { + assert.throws(() => { + decodeRlp("0x"); + }, (error: any) => { + return (error.code === "BUFFER_OVERRUN" && + error.message.match(/^data too short/) && + Buffer.from(error.buffer).toString("hex") === "" && + error.offset === 1 && + error.length === 0) + }); + }); + + it ("fails decoding short data in child", function() { + assert.throws(() => { + decodeRlp("0xc8880102030405060708"); + }, (error: any) => { + return (error.code === "BUFFER_OVERRUN" && + error.message.match(/^child data too short/) && + Buffer.from(error.buffer).toString("hex") === "c8880102030405060708" && + error.offset === 0 && + error.length === 8) + }); + }); + + it ("fails decoding short segment data", function() { + assert.throws(() => { + // [["0x4243"], ["0x3145"]] = 0xc8 c3 82 4243 c3 82 3145 + // XXXX + decodeRlp("0xc8c382c3823145"); + }, (error: any) => { + return (error.code === "BUFFER_OVERRUN" && + error.message.match(/^data short segment too short/) && + Buffer.from(error.buffer).toString("hex") === "c8c382c3823145" && + error.offset === 9 && + error.length === 7) + }); + }); +}); + +/* + utils.RLP.encode([["0x4243"], ["0x3145"]]) + + 0xc8 c3 82 4243 c3 82 3145 + + { + "name": "arrayShort2", + "decoded": [ + "0x48656c6c6f20576f726c64", + "0x48656c6c6f20576f726c64" + ], + "encoded": "0xd8 8b 48656c6c6f20576f726c64 8b 48656c6c6f20576f726c64" + }, +*/ diff --git a/src.ts/_tests/test-transaction.ts b/src.ts/_tests/test-transaction.ts new file mode 100644 index 000000000..c8244b7eb --- /dev/null +++ b/src.ts/_tests/test-transaction.ts @@ -0,0 +1,306 @@ +import assert from "assert"; +import { loadTests } from "./utils.js"; +import type { TestCaseTransaction, TestCaseTransactionTx } from "./types.js"; + + +import { Transaction } from "../index.js"; + + +const BN_0 = BigInt(0); + +describe("Tests Unsigned Transaction Serializing", function() { + const tests = loadTests("transactions"); + + for (const test of tests) { + it(`serialized unsigned legacy transaction: ${ test.name }`, function() { + const txData = Object.assign({ }, test.transaction, { + type: 0, + accessList: undefined, + maxFeePerGas: undefined, + maxPriorityFeePerGas: undefined + }); + + // Use the testcase sans the chainId for a legacy test + if (txData.chainId != null && parseInt(txData.chainId) != 0) { txData.chainId = "0x00"; } + + const tx = Transaction.from(txData); + assert.equal(tx.unsignedSerialized, test.unsignedLegacy, "unsignedLegacy"); + }); + } + + for (const test of tests) { + // Unsupported parameters for EIP-155; i.e. unspecified chain ID + if (!test.unsignedEip155) { continue; } + it(`serialized unsigned EIP-155 transaction: ${ test.name }`, function() { + const txData = Object.assign({ }, test.transaction, { + type: 0, + accessList: undefined, + maxFeePerGas: undefined, + maxPriorityFeePerGas: undefined + }); + + const tx = Transaction.from(txData); + assert.equal(tx.unsignedSerialized, test.unsignedEip155, "unsignedEip155"); + }); + } + + for (const test of tests) { + it(`serialized unsigned Berlin transaction: ${ test.name }`, function() { + const txData = Object.assign({ }, test.transaction, { + type: 1, + maxFeePerGas: undefined, + maxPriorityFeePerGas: undefined + }); + + const tx = Transaction.from(txData); + assert.equal(tx.unsignedSerialized, test.unsignedBerlin, "unsignedBerlin"); + }); + } + + for (const test of tests) { + it(`serialized unsigned London transaction: ${ test.name }`, function() { + const txData = Object.assign({ }, test.transaction, { type: 2 }); + const tx = Transaction.from(txData); + assert.equal(tx.unsignedSerialized, test.unsignedLondon, "unsignedLondon"); + }); + } +}); + +describe("Tests Signed Transaction Serializing", function() { + const tests = loadTests("transactions"); + + for (const test of tests) { + it(`serialized signed legacy transaction: ${ test.name }`, function() { + const txData = Object.assign({ }, test.transaction, { + type: 0, + accessList: undefined, + maxFeePerGas: undefined, + maxPriorityFeePerGas: undefined, + signature: test.signatureLegacy + }); + + // Use the testcase sans the chainId for a legacy test + if (txData.chainId != null && parseInt(txData.chainId) != 0) { txData.chainId = "0x00"; } + + const tx = Transaction.from(txData); + assert.equal(tx.serialized, test.signedLegacy, "signedLegacy"); + }); + } + + for (const test of tests) { + if (!test.unsignedEip155) { continue; } + it(`serialized signed EIP-155 transaction: ${ test.name }`, function() { + const txData = Object.assign({ }, test.transaction, { + type: 0, + accessList: undefined, + maxFeePerGas: undefined, + maxPriorityFeePerGas: undefined, + signature: test.signatureEip155 + }); + + const tx = Transaction.from(txData); + assert.equal(tx.serialized, test.signedEip155, "signedEip155"); + }); + } + + for (const test of tests) { + it(`serialized signed Berlin transaction: ${ test.name }`, function() { + const txData = Object.assign({ }, test.transaction, { + type: 1, + maxFeePerGas: undefined, + maxPriorityFeePerGas: undefined + }, { signature: test.signatureBerlin }); + + const tx = Transaction.from(txData); + assert.equal(tx.serialized, test.signedBerlin, "signedBerlin"); + }); + } + + for (const test of tests) { + it(`serialized signed London transaction: ${ test.name }`, function() { + const txData = Object.assign({ }, test.transaction, { + type: 2, + signature: test.signatureLondon + }); + + const tx = Transaction.from(txData); + assert.equal(tx.serialized, test.signedLondon, "signedLondon"); + }); + } +}); + +function assertTxUint(actual: null | bigint, _expected: undefined | string, name: string): void { + const expected = (_expected != null ? BigInt(_expected): null); + assert.equal(actual, expected, name); +} + +function assertTxEqual(actual: Transaction, expected: TestCaseTransactionTx): void { + assert.equal(actual.to, expected.to, "to"); + assert.equal(actual.nonce, expected.nonce, "nonce"); + + assertTxUint(actual.gasLimit, expected.gasLimit, "gasLimit"); + + assertTxUint(actual.gasPrice, expected.gasPrice, "gasPrice"); + assertTxUint(actual.maxFeePerGas, expected.maxFeePerGas, "maxFeePerGas"); + assertTxUint(actual.maxPriorityFeePerGas, expected.maxPriorityFeePerGas, "maxPriorityFeePerGas"); + + assert.equal(actual.data, expected.data, "data"); + assertTxUint(actual.value, expected.value, "value"); + + if (expected.accessList) { + assert.equal(JSON.stringify(actual.accessList), JSON.stringify(expected.accessList), "accessList"); + } else { + assert.equal(actual.accessList, null, "accessList:!null"); + } + + assertTxUint(actual.chainId, expected.chainId, "chainId"); +} + +function addDefault(tx: any, key: string, defaultValue: any): void { + if (tx[key] == null) { tx[key] = defaultValue; } +} + +function addDefaults(tx: any): any { + tx = Object.assign({ }, tx); + addDefault(tx, "nonce", 0); + addDefault(tx, "gasLimit", BN_0); + addDefault(tx, "gasPrice", BN_0); + addDefault(tx, "maxFeePerGas", BN_0); + addDefault(tx, "maxPriorityFeePerGas", BN_0); + addDefault(tx, "value", BN_0); + addDefault(tx, "data", "0x"); + addDefault(tx, "accessList", [ ]); + addDefault(tx, "chainId", BN_0); + return tx; +} + +describe("Tests Unsigned Transaction Parsing", function() { + const tests = loadTests("transactions"); + + for (const test of tests) { + it(`parses unsigned legacy transaction: ${ test.name }`, function() { + const tx = Transaction.from(test.unsignedLegacy); + + const expected = addDefaults(test.transaction); + expected.maxFeePerGas = null; + expected.maxPriorityFeePerGas = null; + expected.accessList = null; + expected.chainId = BN_0; + + assertTxEqual(tx, expected); + }); + } + + for (const test of tests) { + if (!test.unsignedEip155) { continue; } + it(`parses unsigned EIP-155 transaction: ${ test.name }`, function() { + const tx = Transaction.from(test.unsignedEip155); + + const expected = addDefaults(test.transaction); + expected.maxFeePerGas = null; + expected.maxPriorityFeePerGas = null; + expected.accessList = null; + + assertTxEqual(tx, expected); + }); + } + + for (const test of tests) { + it(`parses unsigned Berlin transaction: ${ test.name }`, function() { + const tx = Transaction.from(test.unsignedBerlin); + + const expected = addDefaults(test.transaction); + expected.maxFeePerGas = null; + expected.maxPriorityFeePerGas = null; + + assertTxEqual(tx, expected); + }); + } + + for (const test of tests) { + it(`parses unsigned London transaction: ${ test.name }`, function() { + const tx = Transaction.from(test.unsignedLondon); + + const expected = addDefaults(test.transaction); + expected.gasPrice = null; + + assertTxEqual(tx, expected); + }); + } +}); + +describe("Tests Signed Transaction Parsing", function() { + const tests = loadTests("transactions"); + + for (const test of tests) { + it(`parses signed legacy transaction: ${ test.name }`, function() { + const tx = Transaction.from(test.signedLegacy); + + const expected = addDefaults(test.transaction); + expected.maxFeePerGas = null; + expected.maxPriorityFeePerGas = null; + expected.accessList = null; + expected.chainId = BN_0; + + assertTxEqual(tx, expected); + + assert.ok(!!tx.signature, "signature:!null") + assert.equal(tx.signature.r, test.signatureLegacy.r, "signature.r"); + assert.equal(tx.signature.s, test.signatureLegacy.s, "signature.s"); + assert.equal(BigInt(tx.signature.v), BigInt(test.signatureLegacy.v), "signature.v"); + }); + } + + for (const test of tests) { + if (!test.unsignedEip155) { continue; } + it(`parses signed EIP-155 transaction: ${ test.name }`, function() { + const tx = Transaction.from(test.signedEip155); + + const expected = addDefaults(test.transaction); + expected.maxFeePerGas = null; + expected.maxPriorityFeePerGas = null; + expected.accessList = null; + + assertTxEqual(tx, expected); + + assert.ok(!!tx.signature, "signature:!null") + assert.equal(tx.signature.r, test.signatureEip155.r, "signature.r"); + assert.equal(tx.signature.s, test.signatureEip155.s, "signature.s"); + assert.equal(tx.signature.networkV, BigInt(test.signatureEip155.v), "signature.v"); + }); + } + + for (const test of tests) { + it(`parses signed Berlin transaction: ${ test.name }`, function() { + const tx = Transaction.from(test.signedBerlin); + + const expected = addDefaults(test.transaction); + expected.maxFeePerGas = null; + expected.maxPriorityFeePerGas = null; + + assertTxEqual(tx, expected); + + assert.ok(!!tx.signature, "signature:!null") + assert.equal(tx.signature.r, test.signatureBerlin.r, "signature.r"); + assert.equal(tx.signature.s, test.signatureBerlin.s, "signature.s"); + assert.equal(tx.signature.yParity, parseInt(test.signatureBerlin.v), "signature.v"); + }); + } + + for (const test of tests) { + it(`parses signed London transaction: ${ test.name }`, function() { + const tx = Transaction.from(test.signedLondon); + + const expected = addDefaults(test.transaction); + expected.gasPrice = null; + + assertTxEqual(tx, expected); + + assert.ok(!!tx.signature, "signature:!null") + assert.equal(tx.signature.r, test.signatureLondon.r, "signature.r"); + assert.equal(tx.signature.s, test.signatureLondon.s, "signature.s"); + assert.equal(tx.signature.yParity, parseInt(test.signatureLondon.v), "signature.v"); + }); + } +}); + diff --git a/src.ts/_tests/test-wallet-hd.ts b/src.ts/_tests/test-wallet-hd.ts new file mode 100644 index 000000000..f1d0e5f89 --- /dev/null +++ b/src.ts/_tests/test-wallet-hd.ts @@ -0,0 +1,155 @@ + +import assert from "assert"; + +import { wordlists } from "../wordlists/wordlists.js"; + +import { loadTests } from "./utils.js"; + +import { HDNodeWallet, HDNodeVoidWallet, Mnemonic } from "../index.js"; + +import type { Wordlist } from "../wordlists/index.js"; + +import type { TestCaseMnemonic, TestCaseMnemonicNode } from "./types.js"; + + +declare global { + class TextDecoder { + decode(data: Uint8Array): string; + } +} + + +const decoder = new TextDecoder(); +function fromHex(hex: string): string { + const data = Buffer.from(hex.substring(2), "hex"); + return decoder.decode(data); +} + +type Test = { + phrase: string; + password: string; + wordlist: Wordlist; + mnemonic: Mnemonic; + checkMnemonic: (a: Mnemonic) => void; + test: TestCaseMnemonic; +}; + +describe("Test HDWallets", function() { + function checkWallet(wallet: HDNodeWallet | HDNodeVoidWallet, test: TestCaseMnemonicNode): void { + assert.equal(wallet.chainCode, test.chainCode, "chainCode"); + assert.equal(wallet.depth, test.depth, "depth"); + assert.equal(wallet.index, test.index, "index"); + assert.equal(wallet.fingerprint, test.fingerprint, "fingerprint"); + assert.equal(wallet.parentFingerprint, test.parentFingerprint, "parentFingerprint"); + assert.equal(wallet.publicKey, test.publicKey, "publicKey"); + + if (wallet instanceof HDNodeWallet) { + assert.equal(wallet.extendedKey, test.xpriv, "xpriv"); + assert.equal(wallet.privateKey, test.privateKey, "privateKey"); + assert.equal(wallet.neuter().extendedKey, test.xpub, "xpub"); + } else if (wallet instanceof HDNodeVoidWallet) { + assert.equal(wallet.extendedKey, test.xpub, "xpub"); + } + } + + const tests = loadTests("mnemonics"); + + const checks: Array = [ ]; + tests.forEach((test) => { + // The phrase and password are stored in the test as hex so they + // are safe as ascii7 values for viewing, printing, etc. + const phrase = fromHex(test.phrase); + const password = fromHex(test.password); + const wordlist = wordlists[test.locale]; + if (wordlist == null) { + it(`tests ${ test.name }`, function() { + this.skip(); + }); + return; + } + + const mnemonic = Mnemonic.fromPhrase(phrase, password, wordlist); + + function checkMnemonic(actual: Mnemonic): void { + assert.equal(actual.phrase, phrase, "phrase"); + assert.equal(actual.password, password, "password"); + assert.equal(actual.wordlist.locale, test.locale, "locale"); + assert.equal(actual.entropy, mnemonic.entropy, "entropy"); + assert.equal(actual.computeSeed(), mnemonic.computeSeed(), "seed"); + } + + checks.push({ + phrase, password, wordlist, mnemonic, checkMnemonic, test + }); + }); + + for (const { test, checkMnemonic, phrase, password, wordlist } of checks) { + it(`computes the HD keys by mnemonic: ${ test.name }`, function() { + for (const subtest of test.nodes) { + const w = HDNodeWallet.fromPhrase(phrase, password, subtest.path, wordlist); + assert.ok(w instanceof HDNodeWallet, "instanceof HDNodeWallet"); + assert.equal(w.path, subtest.path, "path") + checkWallet(w, subtest); + assert.ok(!!w.mnemonic, "has mnemonic"); + checkMnemonic(w.mnemonic as Mnemonic); + } + }); + } + + for (const { test } of checks) { + it(`computes the HD keys by entropy: ${ test.name }`, function() { + const seedRoot = HDNodeWallet.fromSeed(test.seed); + for (const subtest of test.nodes) { + const w = seedRoot.derivePath(subtest.path); + assert.ok(w instanceof HDNodeWallet, "instanceof HDNodeWallet"); + assert.equal(w.path, subtest.path, "path") + checkWallet(w, subtest); + assert.equal(w.mnemonic, null); + } + }); + } + + for (const { test } of checks) { + it(`computes the HD keys by enxtended private key: ${ test.name }`, function() { + for (const subtest of test.nodes) { + const w = HDNodeWallet.fromExtendedKey(subtest.xpriv); + assert.ok(w instanceof HDNodeWallet, "instanceof HDNodeWallet"); + checkWallet(w, subtest); + assert.equal(w.mnemonic, null); + } + }); + } + + for (const { test, phrase, password, wordlist } of checks) { + it(`computes the neutered HD keys by paths: ${ test.name }`, function() { + const root = HDNodeWallet.fromPhrase(phrase, password, "m", wordlist).neuter(); + for (const subtest of test.nodes) { + if (subtest.path.indexOf("'") >= 0) { + assert.throws(() => { + const w = root.derivePath(subtest.path); + console.log(w); + }, (error: any) => { + return (error.code === "UNSUPPORTED_OPERATION" && + error.message.match(/^cannot derive child of neutered node/) && + error.operation === "deriveChild"); + }); + } else { + const w = root.derivePath(subtest.path); + assert.ok(w instanceof HDNodeVoidWallet, "instanceof HDNodeVoidWallet"); + assert.equal(w.path, subtest.path, "path") + checkWallet(w, subtest); + } + } + }); + } + + for (const { test } of checks) { + it(`computes the neutered HD keys by enxtended public key: ${ test.name }`, function() { + for (const subtest of test.nodes) { + const w = HDNodeWallet.fromExtendedKey(subtest.xpub); + assert.ok(w instanceof HDNodeVoidWallet, "instanceof HDNodeVoidWallet"); + checkWallet(w, subtest); + } + }); + } +}); diff --git a/src.ts/_tests/test-wallet-json.ts b/src.ts/_tests/test-wallet-json.ts new file mode 100644 index 000000000..de4a0b3da --- /dev/null +++ b/src.ts/_tests/test-wallet-json.ts @@ -0,0 +1,65 @@ +import assert from "assert"; + +import { loadTests } from "./utils.js"; + +import type { TestCaseWallet } from "./types.js"; + +import { + decryptCrowdsaleJson, + decryptKeystoreJson, decryptKeystoreJsonSync, + Wallet +} from "../index.js"; + +describe("Tests JSON Wallet Formats", function() { + const tests = loadTests("wallets"); + tests.forEach((test) => { + if (test.type !== "crowdsale") { return; } + it(`tests decrypting Crowdsale JSON: ${ test.name }`, async function() { + const password = Buffer.from(test.password.substring(2), "hex"); + const account = decryptCrowdsaleJson(test.content, password); + assert.equal(account.address, test.address, "address"); + }); + }); + + tests.forEach((test) => { + if (test.type !== "keystore") { return; } + it(`tests decrypting Keystore JSON (sync): ${ test.name }`, function() { + this.timeout(20000); + const password = Buffer.from(test.password.substring(2), "hex"); + const account = decryptKeystoreJsonSync(test.content, password); + //console.log(account); + assert.equal(account.address, test.address, "address"); + }); + }); + + tests.forEach((test) => { + if (test.type !== "keystore") { return; } + it(`tests decrypting Keystore JSON (async): ${ test.name }`, async function() { + this.timeout(20000); + const password = Buffer.from(test.password.substring(2), "hex"); + const account = await decryptKeystoreJson(test.content, password); + //console.log(account); + assert.equal(account.address, test.address, "address"); + }); + }); + + tests.forEach((test) => { + it(`tests decrypting JSON (sync): ${ test.name }`, function() { + this.timeout(20000); + const password = Buffer.from(test.password.substring(2), "hex"); + const wallet = Wallet.fromEncryptedJsonSync(test.content, password); + //console.log(wallet); + assert.equal(wallet.address, test.address, "address"); + }); + }); + + tests.forEach((test) => { + it(`tests decrypting JSON (async): ${ test.name }`, async function() { + this.timeout(20000); + const password = Buffer.from(test.password.substring(2), "hex"); + const wallet = await Wallet.fromEncryptedJson(test.content, password); + //console.log(wallet); + assert.equal(wallet.address, test.address, "address"); + }); + }); +}); diff --git a/src.ts/_tests/test-wallet-mnemonic.ts b/src.ts/_tests/test-wallet-mnemonic.ts new file mode 100644 index 000000000..2ec53a713 --- /dev/null +++ b/src.ts/_tests/test-wallet-mnemonic.ts @@ -0,0 +1,143 @@ + +import assert from "assert"; + +import { sha256 } from "../crypto/index.js"; +import { toUtf8Bytes } from "../utils/utf8.js"; + +import { wordlists } from "../wordlists/wordlists.js"; + +import { Mnemonic } from "../index.js"; + +import { loadTests } from "./utils.js"; +import type { TestCaseMnemonic } from "./types.js"; + +const decoder = new TextDecoder(); +function fromHex(hex: string): string { + const data = Buffer.from(hex.substring(2), "hex"); + return decoder.decode(data); +} + +function repeat(text: string, length: number): Array { + const result = [ ]; + while (result.length < length) { result.push(text); } + return result; +} + +describe("Tests Mnemonics", function() { + const tests = loadTests("mnemonics"); + + function runTest(phrase: string, mnemonic: Mnemonic, test: TestCaseMnemonic): void { + assert.ok(Mnemonic.isValidMnemonic(phrase, mnemonic.wordlist), "isValidMnemonic"); + if (test.locale === "en") { + assert.ok(Mnemonic.isValidMnemonic(phrase), "isValidMnemonic (default)"); + } + + assert.equal(mnemonic.wordlist.locale, test.locale, "locale"); + + assert.equal(mnemonic.entropy, test.entropy, "entropy"); + assert.equal(mnemonic.computeSeed(), test.seed, "seed"); + assert.equal(sha256(toUtf8Bytes(phrase)), test.phraseHash, "phraseHash") + } + + for (const test of tests) { + const wordlist = wordlists[test.locale]; + + it(`computes mnemonic from phrase: ${ test.name }`, function() { + if (wordlist == null) { + this.skip(); + return; + } + + const phrase = fromHex(test.phrase); + const password = fromHex(test.password); + const mnemonic = Mnemonic.fromPhrase(phrase, password, wordlist); + runTest(phrase, mnemonic, test); + }); + } + + for (const test of tests) { + const wordlist = wordlists[test.locale]; + + it(`computes mnemonic from entropy: ${ test.name }`, function() { + if (wordlist == null) { + this.skip(); + return; + } + const phrase = fromHex(test.phrase); + const password = fromHex(test.password); + const mnemonic = Mnemonic.fromEntropy(test.entropy, password, wordlist); + runTest(phrase, mnemonic, test); + }); + } +}); + +describe("Tests Bad Mnemonics Fail", function() { + + const badLengths = [ + repeat("abandon", 9), // 9 words; too short + repeat("abandon", 16), // 16 words; not congruent to 0 mod 3 + repeat("abandon", 27), // 27 words; too long + ]; + + for (const _phrase of badLengths) { + const phrase = _phrase.join(" "); + it(`fails on invalid mnemonic length: ${ _phrase.length }`, function() { + assert.ok(!Mnemonic.isValidMnemonic(phrase)); + assert.throws(function() { + Mnemonic.fromPhrase(phrase); + }, function(error: any) { + return (error.code === "INVALID_ARGUMENT" && + error.message.match(/^invalid mnemonic length/) && + error.argument === "mnemonic" && + error.value === "[ REDACTED ]"); + }); + }); + } + + it("fails on invalid mnemonic word", function() { + const phrase = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon wagmi"; + assert.ok(!Mnemonic.isValidMnemonic(phrase)); + assert.throws(function() { + Mnemonic.fromPhrase(phrase); + }, function(error: any) { + return (error.code === "INVALID_ARGUMENT" && + error.message.match(/^invalid mnemonic word at index 11/) && + error.argument === "mnemonic" && + error.value === "[ REDACTED ]"); + }); + }); + + it("fails on invalid mnemonic checksum", function() { + const phrase = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon"; + assert.ok(!Mnemonic.isValidMnemonic(phrase)); + assert.throws(function() { + Mnemonic.fromPhrase(phrase); + }, function(error: any) { + return (error.code === "INVALID_ARGUMENT" && + error.message.match(/^invalid mnemonic checksum/) && + error.argument === "mnemonic" && + error.value === "[ REDACTED ]"); + }); + }); + + + const badEntropyLengths = [ + repeat("42", 12), //12 bytes; too short + repeat("42", 15), // 16 bytes; not congruent to 0 mod 4 + repeat("42", 36), // 36 bytes; too long + ]; + + for (const _entropy of badEntropyLengths) { + const entropy = "0x" + _entropy.join(""); + it(`fails on invalid entropy length: ${ _entropy.length }`, function() { + assert.throws(function() { + Mnemonic.fromEntropy(entropy); + }, function(error: any) { + return (error.code === "INVALID_ARGUMENT" && + error.message.match(/^invalid entropy size/) && + error.argument === "entropy" && + error.value === "[ REDACTED ]"); + }); + }); + } +}) diff --git a/src.ts/_tests/test-wallet.ts b/src.ts/_tests/test-wallet.ts new file mode 100644 index 000000000..8605aa765 --- /dev/null +++ b/src.ts/_tests/test-wallet.ts @@ -0,0 +1,83 @@ +import assert from "assert"; + +import { loadTests } from "./utils.js"; + +import type { + TestCaseAccount, TestCaseTypedData, TestCaseTransaction +} from "./types.js"; + + +import { Wallet } from "../index.js"; + + +describe("Test Private Key Wallet", function() { + const tests = loadTests("accounts"); + + tests.forEach(({ name, privateKey, address }) => { + it(`creates wallet: ${ name }`, function() { + const wallet = new Wallet(privateKey); + assert.equal(wallet.privateKey, privateKey); + assert.equal(wallet.address, address); + }); + }); +}); + +describe("Test Transaction Signing", function() { + const tests = loadTests("transactions"); + for (const test of tests) { + it(`tests signing a legacy transaction: ${ test.name }`, async function() { + const wallet = new Wallet(test.privateKey); + const txData = Object.assign({ }, test.transaction, { type: 0, accessList: undefined, maxFeePerGas: undefined, maxPriorityFeePerGas: undefined }); + + // Use the testcase sans the chainId for a legacy test + if (txData.chainId != null && parseInt(txData.chainId) != 0) { txData.chainId = "0x00"; } + + const signed = await wallet.signTransaction(txData); + assert.equal(signed, test.signedLegacy, "signedLegacy"); + }); + } + + for (const test of tests) { + if (!test.signedEip155) { continue; } + it(`tests signing an EIP-155 transaction: ${ test.name }`, async function() { + const wallet = new Wallet(test.privateKey); + const txData = Object.assign({ }, test.transaction, { type: 0, accessList: undefined, maxFeePerGas: undefined, maxPriorityFeePerGas: undefined }); + const signed = await wallet.signTransaction(txData); + assert.equal(signed, test.signedEip155, "signedEip155"); + }); + } + + for (const test of tests) { + it(`tests signing a Berlin transaction: ${ test.name }`, async function() { + const wallet = new Wallet(test.privateKey); + const txData = Object.assign({ }, test.transaction, { type: 1, maxFeePerGas: undefined, maxPriorityFeePerGas: undefined }); + const signed = await wallet.signTransaction(txData); + assert.equal(signed, test.signedBerlin, "signedBerlin"); + }); + } + + for (const test of tests) { + it(`tests signing a London transaction: ${ test.name }`, async function() { + const wallet = new Wallet(test.privateKey); + const txData = Object.assign({ }, test.transaction, { type: 2 }); + const signed = await wallet.signTransaction(txData); + assert.equal(signed, test.signedLondon, "signedLondon"); + }); + } +}); + +describe("Test Message Signing (EIP-191)", function() { +}); + +describe("Test Typed-Data Signing (EIP-712)", function() { + const tests = loadTests("typed-data"); + for (const test of tests) { + const { privateKey, signature } = test; + if (privateKey == null || signature == null) { continue; } + it(`tests signing typed-data: ${ test.name }`, async function() { + const wallet = new Wallet(privateKey); + const sig = await wallet.signTypedData(test.domain, test.types, test.data); + assert.equal(sig, signature, "signature"); + }); + } +}); diff --git a/src.ts/_tests/test-wordlists.ts b/src.ts/_tests/test-wordlists.ts new file mode 100644 index 000000000..f016f1d40 --- /dev/null +++ b/src.ts/_tests/test-wordlists.ts @@ -0,0 +1,79 @@ +import assert from 'assert'; + +import { wordlists } from "../index.js"; + +import { loadTests } from "./utils.js"; + +import type { TestCaseWordlist } from "./types.js"; + + +describe('Check Wordlists', function() { + const tests = loadTests("wordlists"); + + tests.forEach((test) => { + let wordlist = wordlists[test.locale]; + if (wordlist == null) { return; } + + it(`matches wordlists: ${ test.locale }`, function() { + const words = test.content.split('\n'); + + let check = ""; + for (let i = 0; i < 2048; i++) { + let word = wordlist.getWord(i); + check += (word + "\n"); + assert.equal(word, words[i]); + assert.equal(wordlist.getWordIndex(word), i); + } + + assert.equal(check, test.content); + }); + }); + + tests.forEach((test) => { + let wordlist = wordlists[test.locale]; + if (wordlist == null) { return; } + + it (`splitting and joining are equivalent: ${ test.locale }`, function() { + const words: Array = [ ]; + for (let i = 0; i < 12; i++) { + words.push(wordlist.getWord(i)); + } + + const phrase = wordlist.join(words); + + const words2 = wordlist.split(phrase); + const phrase2 = wordlist.join(words2); + + assert.deepStrictEqual(words2, words, "split words"); + assert.deepStrictEqual(phrase2, phrase, "re-joined words"); + }); + }); + + tests.forEach((test) => { + let wordlist = wordlists[test.locale]; + if (wordlist == null) { return; } + + it(`handles out-of-range values: ${ test.locale }`, function() { + assert.equal(wordlist.getWordIndex("foobar"), -1); + + assert.throws(() => { + wordlist.getWord(-1); + }, (error: any) => { + return (error.code === "INVALID_ARGUMENT" && + error.message.match(/^invalid word index/) && + error.argument === "index" && + error.value === -1); + }); + + assert.throws(() => { + wordlist.getWord(2048); + }, (error: any) => { + return (error.code === "INVALID_ARGUMENT" && + error.message.match(/^invalid word index/) && + error.argument === "index" && + error.value === 2048); + }); + }); + + }); +}); diff --git a/src.ts/_tests/types.ts b/src.ts/_tests/types.ts new file mode 100644 index 000000000..617cb4037 --- /dev/null +++ b/src.ts/_tests/types.ts @@ -0,0 +1,245 @@ + + +export type TestCaseAbiVerbose = { + type: "address" | "hexstring" | "number" | "string", + value: string +} | { + type: "boolean", + value: boolean +} | { + type: "array", + value: Array +} | { + type: "object", + value: Array +} + +export interface TestCaseAbi { + name: string; + type: string; + value: any; + verbose: TestCaseAbiVerbose; + bytecode: string; + encoded: string; +} + +///////////////////////////// +// address + +export interface TestCaseAccount { + name: string; + privateKey: string; + address: string; + icap: string; +} + +export type TestCaseCreate = { + sender: string; + creates: Array<{ + name: string, + nonce: number, + address: string + }>; +}; + +export type TestCaseCreate2 = { + sender: string; + creates: Array<{ + name: string, + salt: string; + initCode: string + initCodeHash: string + address: string; + }>; +}; + + +///////////////////////////// +// crypto + +export interface TestCaseHash { + name: string; + data: string; + sha256: string; + sha512: string; + ripemd160: string; + keccak256: string; +} + +export interface TestCasePbkdf { + name: string; + password: string; + salt: string; + dkLen: number; + pbkdf2: { + iterations: number; + algorithm: "sha256" | "sha512"; + key: string; + }, + scrypt: { + N: number; + r: number; + p: number; + key: string; + } +} + +export interface TestCaseHmac { + name: string; + data: string; + key: string; + algorithm: "sha256" | "sha512"; + hmac: string; +} + +///////////////////////////// +// hash + +export interface TestCaseHash { + name: string; + data: string; + sha256: string; + sha512: string; + ripemd160: string; + keccak256: string; +} + +export interface TestCaseNamehash { + name: string; + ensName: string; + namehash: string; +} + +export interface TestCaseTypedDataDomain { + name?: string; + version?: string; + chainId?: number; + verifyingContract?: string; + salt?: string; +} + +export interface TestCaseTypedDataType { + name: string; + type: string; +} + +export interface TestCaseTypedData { + name: string; + + domain: TestCaseTypedDataDomain; + primaryType: string; + types: Record> + data: any; + + encoded: string; + digest: string; + + privateKey?: string; + signature?: string; +} + + +///////////////////////////// +// rlp + +export type NestedHexString = string | Array; + +export interface TestCaseRlp { + name: string; + encoded: string; + decoded: NestedHexString; +} + + +///////////////////////////// +// transaction + +export interface TestCaseTransactionTx { + to?: string; + nonce?: number; + gasLimit?: string; + + gasPrice?: string; + maxFeePerGas?: string; + maxPriorityFeePerGas?: string; + + data?: string; + value?: string; + + accessList?: Array<{ address: string, storageKeys: Array }>; + + chainId?: string; +} + +export interface TestCaseTransactionSig { + r: string; + s: string; + v: string; +} + +export interface TestCaseTransaction { + name: string; + transaction: TestCaseTransactionTx; + privateKey: string; + + unsignedLegacy: string; + signedLegacy: string; + unsignedEip155: string; + signedEip155: string; + unsignedBerlin: string; + signedBerlin: string; + unsignedLondon: string; + signedLondon: string; + + signatureLegacy: TestCaseTransactionSig; + signatureEip155: TestCaseTransactionSig; + signatureBerlin: TestCaseTransactionSig; + signatureLondon: TestCaseTransactionSig; +} + + +///////////////////////////// +// wallet + +export interface TestCaseMnemonicNode { + path: string, + chainCode: string; + depth: number; + index: number; + parentFingerprint: string; + fingerprint: string; + publicKey: string; + privateKey: string; + xpriv: string; + xpub: string; +} + +export interface TestCaseMnemonic { + name: string; + phrase: string; + phraseHash: string; + password: string; + locale: string; + entropy: string; + seed: string; + nodes: Array; +}; + +export interface TestCaseWallet { + name: string; + filename: string, + type: string; + address: string; + password: string; + content: string; +} + +///////////////////////////// +// wordlists + +export interface TestCaseWordlist { + name: string; + filename: string, + locale: string; + content: string; +} diff --git a/src.ts/_tests/utils.ts b/src.ts/_tests/utils.ts new file mode 100644 index 000000000..6aeef552b --- /dev/null +++ b/src.ts/_tests/utils.ts @@ -0,0 +1,32 @@ + +import fs from "fs" +import path from "path"; +import zlib from 'zlib'; + +// Find the package root (based on the nyc output/ folder) +const root = (function() { + let root = process.cwd(); + + while (true) { + if (fs.existsSync(path.join(root, "output"))) { return root; } + const parent = path.join(root, ".."); + if (parent === root) { break; } + root = parent; + } + + throw new Error("could not find root"); +})(); + +// Load the tests +export function loadTests(tag: string): Array { + const filename = path.resolve(root, "testcases", tag + ".json.gz"); + return JSON.parse(zlib.gunzipSync(fs.readFileSync(filename)).toString()); +} + +export function log(context: any, text: string): void { + if (context && context.test && typeof(context.test._ethersLog) === "function") { + context.test._ethersLog(text); + } else { + console.log(text); + } +} diff --git a/src.ts/_version.ts b/src.ts/_version.ts new file mode 100644 index 000000000..f79f7e742 --- /dev/null +++ b/src.ts/_version.ts @@ -0,0 +1 @@ +export const version = "6.0.0-beta-exports.0"; \ No newline at end of file diff --git a/src.ts/abi/abi-coder.ts b/src.ts/abi/abi-coder.ts new file mode 100644 index 000000000..c9115c54b --- /dev/null +++ b/src.ts/abi/abi-coder.ts @@ -0,0 +1,95 @@ +// See: https://github.com/ethereum/wiki/wiki/Ethereum-Contract-ABI + +import { logger } from "../utils/logger.js"; + +import { Coder, Reader, Result, Writer } from "./coders/abstract-coder.js"; +import { AddressCoder } from "./coders/address.js"; +import { ArrayCoder } from "./coders/array.js"; +import { BooleanCoder } from "./coders/boolean.js"; +import { BytesCoder } from "./coders/bytes.js"; +import { FixedBytesCoder } from "./coders/fixed-bytes.js"; +import { NullCoder } from "./coders/null.js"; +import { NumberCoder } from "./coders/number.js"; +import { StringCoder } from "./coders/string.js"; +import { TupleCoder } from "./coders/tuple.js"; +import { ParamType } from "./fragments.js"; + +import type { BytesLike } from "../utils/index.js"; + + +const paramTypeBytes = new RegExp(/^bytes([0-9]*)$/); +const paramTypeNumber = new RegExp(/^(u?int)([0-9]*)$/); + +export class AbiCoder { + + #getCoder(param: ParamType): Coder { + if (param.isArray()) { + return new ArrayCoder(this.#getCoder(param.arrayChildren), param.arrayLength, param.name); + } + + if (param.isTuple()) { + return new TupleCoder(param.components.map((c) => this.#getCoder(c)), param.name); + } + + switch (param.baseType) { + case "address": + return new AddressCoder(param.name); + case "bool": + return new BooleanCoder(param.name); + case "string": + return new StringCoder(param.name); + case "bytes": + return new BytesCoder(param.name); + case "": + return new NullCoder(param.name); + } + + // u?int[0-9]* + let match = param.type.match(paramTypeNumber); + if (match) { + let size = parseInt(match[2] || "256"); + if (size === 0 || size > 256 || (size % 8) !== 0) { + logger.throwArgumentError("invalid " + match[1] + " bit length", "param", param); + } + return new NumberCoder(size / 8, (match[1] === "int"), param.name); + } + + // bytes[0-9]+ + match = param.type.match(paramTypeBytes); + if (match) { + let size = parseInt(match[1]); + if (size === 0 || size > 32) { + logger.throwArgumentError("invalid bytes length", "param", param); + } + return new FixedBytesCoder(size, param.name); + } + + return logger.throwArgumentError("invalid type", "type", param.type); + } + + getDefaultValue(types: ReadonlyArray): Result { + const coders: Array = types.map((type) => this.#getCoder(ParamType.from(type))); + const coder = new TupleCoder(coders, "_"); + return coder.defaultValue(); + } + + encode(types: ReadonlyArray, values: ReadonlyArray): string { + logger.assertArgumentCount(values.length, types.length, "types/values length mismatch"); + + const coders = types.map((type) => this.#getCoder(ParamType.from(type))); + const coder = (new TupleCoder(coders, "_")); + + const writer = new Writer(); + coder.encode(writer, values); + return writer.data; + } + + decode(types: ReadonlyArray, data: BytesLike, loose?: boolean): Result { + const coders: Array = types.map((type) => this.#getCoder(ParamType.from(type))); + const coder = new TupleCoder(coders, "_"); + return coder.decode(new Reader(data, loose)); + } +} + + +export const defaultAbiCoder: AbiCoder = new AbiCoder(); diff --git a/src.ts/abi/bytes32.ts b/src.ts/abi/bytes32.ts new file mode 100644 index 000000000..4dc767bb3 --- /dev/null +++ b/src.ts/abi/bytes32.ts @@ -0,0 +1,37 @@ + +import { zeroPadBytes } from "../utils/data.js"; + +import { logger } from "../utils/logger.js"; + +import { toUtf8Bytes, toUtf8String } from "../utils/utf8.js"; + +import type { BytesLike } from "../utils/index.js"; + + +export function formatBytes32String(text: string): string { + + // Get the bytes + const bytes = toUtf8Bytes(text); + + // Check we have room for null-termination + if (bytes.length > 31) { throw new Error("bytes32 string must be less than 32 bytes"); } + + // Zero-pad (implicitly null-terminates) + return zeroPadBytes(bytes, 32); +} + +export function parseBytes32String(_bytes: BytesLike): string { + const data = logger.getBytes(_bytes, "bytes"); + + // Must be 32 bytes with a null-termination + if (data.length !== 32) { throw new Error("invalid bytes32 - not 32 bytes long"); } + if (data[31] !== 0) { throw new Error("invalid bytes32 string - no null terminator"); } + + // Find the null termination + let length = 31; + while (data[length - 1] === 0) { length--; } + + // Determine the string value + return toUtf8String(data.slice(0, length)); +} + diff --git a/src.ts/abi/coders/abstract-coder.ts b/src.ts/abi/coders/abstract-coder.ts new file mode 100644 index 000000000..bd3a28b8d --- /dev/null +++ b/src.ts/abi/coders/abstract-coder.ts @@ -0,0 +1,318 @@ + +import { toArray, toBigInt, toNumber } from "../../utils/maths.js"; +import { concat, hexlify } from "../../utils/data.js"; +import { defineProperties } from "../../utils/properties.js"; + +import { logger } from "../../utils/logger.js"; + +import type { BigNumberish, BytesLike } from "../../utils/index.js"; + +export const WordSize = 32; +const Padding = new Uint8Array(WordSize); + +// Properties used to immediate pass through to the underlying object +// - `then` is used to detect if an object is a Promise for await +const passProperties = [ "then" ]; + +const _guard = { }; + +export class Result extends Array { + #indices: Map>; + + [ K: string | number ]: any + + constructor(guard: any, items: Array, keys?: Array) { + logger.assertPrivate(guard, _guard, "Result"); + super(...items); + + // Name lookup table + this.#indices = new Map(); + + if (keys) { + keys.forEach((key, index) => { + if (key == null) { return; } + if (this.#indices.has(key)) { + (>(this.#indices.get(key))).push(index); + } else { + this.#indices.set(key, [ index ]); + } + }); + } + Object.freeze(this); + + return new Proxy(this, { + get: (target, prop, receiver) => { + if (typeof(prop) === "string") { + if (prop.match(/^[0-9]+$/)) { + const index = logger.getNumber(prop, "%index"); + if (index < 0 || index >= this.length) { + throw new RangeError("out of result range"); + } + + const item = target[index]; + if (item instanceof Error) { + this.#throwError(`index ${ index }`, item); + } + return item; + } + + // Pass important checks (like `then` for Promise) through + if (prop in target || passProperties.indexOf(prop) >= 0) { + return Reflect.get(target, prop, receiver); + } + + // Something that could be a result keyword value + if (!(prop in target)) { + return target.getValue(prop); + } + } + + return Reflect.get(target, prop, receiver); + } + }); + } + + /* + toJSON(): any { + if (this.#indices.length === this.length) { + const result: Record = { }; + for (const key of this.#indices.keys()) { + result[key] = ths.getValue(key); + } + return result; + } + return this; + } + */ + + slice(start?: number | undefined, end?: number | undefined): Array { + if (start == null) { start = 0; } + if (end == null) { end = this.length; } + + const result = [ ]; + for (let i = start; i < end; i++) { + let value: any; + try { + value = this[i]; + } catch (error: any) { + value = error.error; + } + result.push(value); + } + return result; + } + + #throwError(name: string, error: Error): never { + const wrapped = new Error(`deferred error during ABI decoding triggered accessing ${ name }`); + (wrapped).error = error; + throw wrapped; + } + + getValue(name: string): any { + const index = this.#indices.get(name); + if (index != null && index.length === 1) { + const item = this[index[0]]; + if (item instanceof Error) { + this.#throwError(`property ${ JSON.stringify(name) }`, item); + } + return item; + } + + throw new Error(`no named parameter: ${ JSON.stringify(name) }`); + } + + static fromItems(items: Array, keys?: Array) { + return new Result(_guard, items, keys); + } +} + +export function checkResultErrors(result: Result): Array<{ path: Array, error: Error }> { + // Find the first error (if any) + const errors: Array<{ path: Array, error: Error }> = [ ]; + + const checkErrors = function(path: Array, object: any): void { + if (!Array.isArray(object)) { return; } + for (let key in object) { + const childPath = path.slice(); + childPath.push(key); + + try { + checkErrors(childPath, object[key]); + } catch (error: any) { + errors.push({ path: childPath, error: error }); + } + } + } + checkErrors([ ], result); + + return errors; + +} + +function getValue(value: BigNumberish): Uint8Array { + let bytes = toArray(value); + + if (bytes.length > WordSize) { + logger.throwError("value out-of-bounds", "BUFFER_OVERRUN", { + buffer: bytes, + length: WordSize, + offset: bytes.length + }); + } + + if (bytes.length !== WordSize) { + bytes = logger.getBytesCopy(concat([ Padding.slice(bytes.length % WordSize), bytes ])); + } + + return bytes; +} + + +export abstract class Coder { + + // The coder name: + // - address, uint256, tuple, array, etc. + readonly name!: string; + + // The fully expanded type, including composite types: + // - address, uint256, tuple(address,bytes), uint256[3][4][], etc. + readonly type!: string; + + // The localName bound in the signature, in this example it is "baz": + // - tuple(address foo, uint bar) baz + readonly localName!: string; + + // Whether this type is dynamic: + // - Dynamic: bytes, string, address[], tuple(boolean[]), etc. + // - Not Dynamic: address, uint256, boolean[3], tuple(address, uint8) + readonly dynamic!: boolean; + + constructor(name: string, type: string, localName: string, dynamic: boolean) { + defineProperties(this, { name, type, localName, dynamic }, { + name: "string", type: "string", localName: "string", dynamic: "boolean" + }); + } + + _throwError(message: string, value: any): never { + return logger.throwArgumentError(message, this.localName, value); + } + + abstract encode(writer: Writer, value: any): number; + abstract decode(reader: Reader): any; + + abstract defaultValue(): any; +} + +export class Writer { + // An array of WordSize lengthed objects to concatenation + #data: Array; + #dataLength: number; + + constructor() { + this.#data = [ ]; + this.#dataLength = 0; + } + + get data(): string { + return concat(this.#data); + } + get length(): number { return this.#dataLength; } + + #writeData(data: Uint8Array): number { + this.#data.push(data); + this.#dataLength += data.length; + return data.length; + } + + appendWriter(writer: Writer): number { + return this.#writeData(logger.getBytesCopy(writer.data)); + } + + // Arrayish item; pad on the right to *nearest* WordSize + writeBytes(value: BytesLike): number { + let bytes = logger.getBytesCopy(value); + const paddingOffset = bytes.length % WordSize; + if (paddingOffset) { + bytes = logger.getBytesCopy(concat([ bytes, Padding.slice(paddingOffset) ])) + } + return this.#writeData(bytes); + } + + // Numeric item; pad on the left *to* WordSize + writeValue(value: BigNumberish): number { + return this.#writeData(getValue(value)); + } + + // Inserts a numeric place-holder, returning a callback that can + // be used to asjust the value later + writeUpdatableValue(): (value: BigNumberish) => void { + const offset = this.#data.length; + this.#data.push(Padding); + this.#dataLength += WordSize; + return (value: BigNumberish) => { + this.#data[offset] = getValue(value); + }; + } +} + +export class Reader { + // Allows incomplete unpadded data to be read; otherwise an error + // is raised if attempting to overrun the buffer. This is required + // to deal with an old Solidity bug, in which event data for + // external (not public thoguh) was tightly packed. + readonly allowLoose!: boolean; + + readonly #data: Uint8Array; + #offset: number; + + constructor(data: BytesLike, allowLoose?: boolean) { + defineProperties(this, { allowLoose: !!allowLoose }); + + this.#data = logger.getBytesCopy(data); + + this.#offset = 0; + } + + get data(): string { return hexlify(this.#data); } + get dataLength(): number { return this.#data.length; } + get consumed(): number { return this.#offset; } + get bytes(): Uint8Array { return new Uint8Array(this.#data); } + + #peekBytes(offset: number, length: number, loose?: boolean): Uint8Array { + let alignedLength = Math.ceil(length / WordSize) * WordSize; + if (this.#offset + alignedLength > this.#data.length) { + if (this.allowLoose && loose && this.#offset + length <= this.#data.length) { + alignedLength = length; + } else { + logger.throwError("data out-of-bounds", "BUFFER_OVERRUN", { + buffer: logger.getBytesCopy(this.#data), + length: this.#data.length, + offset: this.#offset + alignedLength + }); + } + } + return this.#data.slice(this.#offset, this.#offset + alignedLength) + } + + // Create a sub-reader with the same underlying data, but offset + subReader(offset: number): Reader { + return new Reader(this.#data.slice(this.#offset + offset), this.allowLoose); + } + + // Read bytes + readBytes(length: number, loose?: boolean): Uint8Array { + let bytes = this.#peekBytes(0, length, !!loose); + this.#offset += bytes.length; + // @TODO: Make sure the length..end bytes are all 0? + return bytes.slice(0, length); + } + + // Read a numeric values + readValue(): bigint { + return toBigInt(this.readBytes(WordSize)); + } + + readIndex(): number { + return toNumber(this.readBytes(WordSize)); + } +} diff --git a/src.ts/abi/coders/address.ts b/src.ts/abi/coders/address.ts new file mode 100644 index 000000000..2a78380ef --- /dev/null +++ b/src.ts/abi/coders/address.ts @@ -0,0 +1,33 @@ +import { getAddress } from "../../address/index.js"; +import { toHex } from "../../utils/maths.js"; + +import { Typed } from "../typed.js"; +import { Coder } from "./abstract-coder.js"; + +import type { Reader, Writer } from "./abstract-coder.js"; + + +export class AddressCoder extends Coder { + + constructor(localName: string) { + super("address", "address", localName, false); + } + + defaultValue(): string { + return "0x0000000000000000000000000000000000000000"; + } + + encode(writer: Writer, _value: string | Typed): number { + let value = Typed.dereference(_value, "string"); + try { + value = getAddress(value); + } catch (error: any) { + return this._throwError(error.message, _value); + } + return writer.writeValue(value); + } + + decode(reader: Reader): any { + return getAddress(toHex(reader.readValue(), 20)); + } +} diff --git a/src.ts/abi/coders/anonymous.ts b/src.ts/abi/coders/anonymous.ts new file mode 100644 index 000000000..3b06e881f --- /dev/null +++ b/src.ts/abi/coders/anonymous.ts @@ -0,0 +1,25 @@ +import { Coder } from "./abstract-coder.js"; + +import type { Reader, Writer } from "./abstract-coder.js"; + +// Clones the functionality of an existing Coder, but without a localName +export class AnonymousCoder extends Coder { + private coder: Coder; + + constructor(coder: Coder) { + super(coder.name, coder.type, "_", coder.dynamic); + this.coder = coder; + } + + defaultValue(): any { + return this.coder.defaultValue(); + } + + encode(writer: Writer, value: any): number { + return this.coder.encode(writer, value); + } + + decode(reader: Reader): any { + return this.coder.decode(reader); + } +} diff --git a/src.ts/abi/coders/array.ts b/src.ts/abi/coders/array.ts new file mode 100644 index 000000000..51c749027 --- /dev/null +++ b/src.ts/abi/coders/array.ts @@ -0,0 +1,208 @@ +import { defineProperties } from "../../utils/properties.js"; +import { isError } from "../../utils/errors.js"; +import { logger } from "../../utils/logger.js"; + +import { Typed } from "../typed.js"; +import { Coder, Result, WordSize, Writer } from "./abstract-coder.js"; +import { AnonymousCoder } from "./anonymous.js"; + +import type { Reader } from "./abstract-coder.js"; + + +export function pack(writer: Writer, coders: ReadonlyArray, values: Array | { [ name: string ]: any }): number { + let arrayValues: Array = [ ]; + + if (Array.isArray(values)) { + arrayValues = values; + + } else if (values && typeof(values) === "object") { + let unique: { [ name: string ]: boolean } = { }; + + arrayValues = coders.map((coder) => { + const name = coder.localName; + if (!name) { + logger.throwError("cannot encode object for signature with missing names", "INVALID_ARGUMENT", { + argument: "values", + info: { coder }, + value: values + }); + } + + if (unique[name]) { + logger.throwError("cannot encode object for signature with duplicate names", "INVALID_ARGUMENT", { + argument: "values", + info: { coder }, + value: values + }); + } + + unique[name] = true; + + return values[name]; + }); + + } else { + logger.throwArgumentError("invalid tuple value", "tuple", values); + } + + if (coders.length !== arrayValues.length) { + logger.throwArgumentError("types/value length mismatch", "tuple", values); + } + + let staticWriter = new Writer(); + let dynamicWriter = new Writer(); + + let updateFuncs: Array<(baseOffset: number) => void> = []; + coders.forEach((coder, index) => { + let value = arrayValues[index]; + + if (coder.dynamic) { + // Get current dynamic offset (for the future pointer) + let dynamicOffset = dynamicWriter.length; + + // Encode the dynamic value into the dynamicWriter + coder.encode(dynamicWriter, value); + + // Prepare to populate the correct offset once we are done + let updateFunc = staticWriter.writeUpdatableValue(); + updateFuncs.push((baseOffset: number) => { + updateFunc(baseOffset + dynamicOffset); + }); + + } else { + coder.encode(staticWriter, value); + } + }); + + // Backfill all the dynamic offsets, now that we know the static length + updateFuncs.forEach((func) => { func(staticWriter.length); }); + + let length = writer.appendWriter(staticWriter); + length += writer.appendWriter(dynamicWriter); + return length; +} + +export function unpack(reader: Reader, coders: ReadonlyArray): Result { + let values: Array = []; + let keys: Array = [ ]; + + // A reader anchored to this base + let baseReader = reader.subReader(0); + + coders.forEach((coder) => { + let value: any = null; + + if (coder.dynamic) { + let offset = reader.readIndex(); + let offsetReader = baseReader.subReader(offset); + try { + value = coder.decode(offsetReader); + } catch (error: any) { + // Cannot recover from this + if (isError(error, "BUFFER_OVERRUN")) { + throw error; + } + + value = error; + value.baseType = coder.name; + value.name = coder.localName; + value.type = coder.type; + } + + } else { + try { + value = coder.decode(reader); + } catch (error: any) { + // Cannot recover from this + if (isError(error, "BUFFER_OVERRUN")) { + throw error; + } + + value = error; + value.baseType = coder.name; + value.name = coder.localName; + value.type = coder.type; + } + } + + if (value == undefined) { + throw new Error("investigate"); + } + + values.push(value); + keys.push(coder.localName || null); + }); + + return Result.fromItems(values, keys); +} + + +export class ArrayCoder extends Coder { + readonly coder!: Coder; + readonly length!: number; + + constructor(coder: Coder, length: number, localName: string) { + const type = (coder.type + "[" + (length >= 0 ? length: "") + "]"); + const dynamic = (length === -1 || coder.dynamic); + super("array", type, localName, dynamic); + defineProperties(this, { coder, length }); + } + + defaultValue(): Array { + // Verifies the child coder is valid (even if the array is dynamic or 0-length) + const defaultChild = this.coder.defaultValue(); + + const result: Array = []; + for (let i = 0; i < this.length; i++) { + result.push(defaultChild); + } + return result; + } + + encode(writer: Writer, _value: Array | Typed): number { + const value = Typed.dereference(_value, "array"); + + if (!Array.isArray(value)) { + this._throwError("expected array value", value); + } + + let count = this.length; + + if (count === -1) { + count = value.length; + writer.writeValue(value.length); + } + + logger.assertArgumentCount(value.length, count, "coder array" + (this.localName? (" "+ this.localName): "")); + + let coders = []; + for (let i = 0; i < value.length; i++) { coders.push(this.coder); } + + return pack(writer, coders, value); + } + + decode(reader: Reader): any { + let count = this.length; + if (count === -1) { + count = reader.readIndex(); + + // Check that there is *roughly* enough data to ensure + // stray random data is not being read as a length. Each + // slot requires at least 32 bytes for their value (or 32 + // bytes as a link to the data). This could use a much + // tighter bound, but we are erroring on the side of safety. + if (count * WordSize > reader.dataLength) { + logger.throwError("insufficient data length", "BUFFER_OVERRUN", { + buffer: reader.bytes, + offset: count * WordSize, + length: reader.dataLength + }); + } + } + let coders = []; + for (let i = 0; i < count; i++) { coders.push(new AnonymousCoder(this.coder)); } + + return unpack(reader, coders); + } +} + diff --git a/src.ts/abi/coders/boolean.ts b/src.ts/abi/coders/boolean.ts new file mode 100644 index 000000000..5dbf82edd --- /dev/null +++ b/src.ts/abi/coders/boolean.ts @@ -0,0 +1,25 @@ +import { Typed } from "../typed.js"; +import { Coder } from "./abstract-coder.js"; + +import type { Reader, Writer } from "./abstract-coder.js"; + + +export class BooleanCoder extends Coder { + + constructor(localName: string) { + super("bool", "bool", localName, false); + } + + defaultValue(): boolean { + return false; + } + + encode(writer: Writer, _value: boolean | Typed): number { + const value = Typed.dereference(_value, "bool"); + return writer.writeValue(value ? 1: 0); + } + + decode(reader: Reader): any { + return !!reader.readValue(); + } +} diff --git a/src.ts/abi/coders/bytes.ts b/src.ts/abi/coders/bytes.ts new file mode 100644 index 000000000..f5b4338ad --- /dev/null +++ b/src.ts/abi/coders/bytes.ts @@ -0,0 +1,38 @@ +import { logger } from "../../utils/logger.js"; +import { hexlify } from "../../utils/data.js"; + +import { Coder } from "./abstract-coder.js"; + +import type { Reader, Writer } from "./abstract-coder.js"; + + +export class DynamicBytesCoder extends Coder { + constructor(type: string, localName: string) { + super(type, type, localName, true); + } + + defaultValue(): string { + return "0x"; + } + + encode(writer: Writer, value: any): number { + value = logger.getBytesCopy(value); + let length = writer.writeValue(value.length); + length += writer.writeBytes(value); + return length; + } + + decode(reader: Reader): any { + return reader.readBytes(reader.readIndex(), true); + } +} + +export class BytesCoder extends DynamicBytesCoder { + constructor(localName: string) { + super("bytes", localName); + } + + decode(reader: Reader): any { + return hexlify(super.decode(reader)); + } +} diff --git a/src.ts/abi/coders/fixed-bytes.ts b/src.ts/abi/coders/fixed-bytes.ts new file mode 100644 index 000000000..466feddd1 --- /dev/null +++ b/src.ts/abi/coders/fixed-bytes.ts @@ -0,0 +1,36 @@ + +import { logger } from "../../utils/logger.js"; +import { hexlify } from "../../utils/data.js"; +import { defineProperties } from "../../utils/properties.js"; + +import { Typed } from "../typed.js"; +import { Coder } from "./abstract-coder.js"; + +import type { BytesLike } from "../../utils/index.js"; + +import type { Reader, Writer } from "./abstract-coder.js"; + + +export class FixedBytesCoder extends Coder { + readonly size!: number; + + constructor(size: number, localName: string) { + let name = "bytes" + String(size); + super(name, name, localName, false); + defineProperties(this, { size }, { size: "number" }); + } + + defaultValue(): string { + return ("0x0000000000000000000000000000000000000000000000000000000000000000").substring(0, 2 + this.size * 2); + } + + encode(writer: Writer, _value: BytesLike | Typed): number { + let data = logger.getBytesCopy(Typed.dereference(_value, this.type)); + if (data.length !== this.size) { this._throwError("incorrect data length", _value); } + return writer.writeBytes(data); + } + + decode(reader: Reader): any { + return hexlify(reader.readBytes(this.size)); + } +} diff --git a/src.ts/abi/coders/null.ts b/src.ts/abi/coders/null.ts new file mode 100644 index 000000000..7a2e796f8 --- /dev/null +++ b/src.ts/abi/coders/null.ts @@ -0,0 +1,25 @@ +import { Coder } from "./abstract-coder.js"; +import type { Reader, Writer } from "./abstract-coder.js"; + +const Empty = new Uint8Array([ ]); + +export class NullCoder extends Coder { + + constructor(localName: string) { + super("null", "", localName, false); + } + + defaultValue(): null { + return null; + } + + encode(writer: Writer, value: any): number { + if (value != null) { this._throwError("not null", value); } + return writer.writeBytes(Empty); + } + + decode(reader: Reader): any { + reader.readBytes(0); + return null; + } +} diff --git a/src.ts/abi/coders/number.ts b/src.ts/abi/coders/number.ts new file mode 100644 index 000000000..1851346dc --- /dev/null +++ b/src.ts/abi/coders/number.ts @@ -0,0 +1,65 @@ +import { fromTwos, mask, toTwos } from "../../utils/maths.js"; +import { defineProperties } from "../../utils/properties.js"; + +import { logger } from "../../utils/logger.js"; +import { Typed } from "../typed.js"; +import { Coder, WordSize } from "./abstract-coder.js"; + +import type { BigNumberish } from "../../utils/index.js"; + +import type { Reader, Writer } from "./abstract-coder.js"; + + +const BN_0 = BigInt(0); +const BN_1 = BigInt(1); +const BN_MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); + +export class NumberCoder extends Coder { + readonly size!: number; + readonly signed!: boolean; + + constructor(size: number, signed: boolean, localName: string) { + const name = ((signed ? "int": "uint") + (size * 8)); + super(name, name, localName, false); + + defineProperties(this, { size, signed }, { size: "number", signed: "boolean" }); + } + + defaultValue(): number { + return 0; + } + + encode(writer: Writer, _value: BigNumberish | Typed): number { + let value = logger.getBigInt(Typed.dereference(_value, this.type)); + + // Check bounds are safe for encoding + let maxUintValue = mask(BN_MAX_UINT256, WordSize * 8); + if (this.signed) { + let bounds = mask(maxUintValue, (this.size * 8) - 1); + if (value > bounds || value < -(bounds + BN_1)) { + this._throwError("value out-of-bounds", _value); + } + } else if (value < BN_0 || value > mask(maxUintValue, this.size * 8)) { + this._throwError("value out-of-bounds", _value); + } + + value = mask(toTwos(value, this.size * 8), this.size * 8); + + if (this.signed) { + value = toTwos(fromTwos(value, this.size * 8), 8 * WordSize); + } + + return writer.writeValue(value); + } + + decode(reader: Reader): any { + let value = mask(reader.readValue(), this.size * 8); + + if (this.signed) { + value = fromTwos(value, this.size * 8); + } + + return value; + } +} + diff --git a/src.ts/abi/coders/string.ts b/src.ts/abi/coders/string.ts new file mode 100644 index 000000000..7efeff097 --- /dev/null +++ b/src.ts/abi/coders/string.ts @@ -0,0 +1,26 @@ +import { toUtf8Bytes, toUtf8String } from "../../utils/utf8.js"; + +import { Typed } from "../typed.js"; +import { DynamicBytesCoder } from "./bytes.js"; + +import type { Reader, Writer } from "./abstract-coder.js"; + + +export class StringCoder extends DynamicBytesCoder { + + constructor(localName: string) { + super("string", localName); + } + + defaultValue(): string { + return ""; + } + + encode(writer: Writer, _value: string | Typed): number { + return super.encode(writer, toUtf8Bytes(Typed.dereference(_value, "string"))); + } + + decode(reader: Reader): any { + return toUtf8String(super.decode(reader)); + } +} diff --git a/src.ts/abi/coders/tuple.ts b/src.ts/abi/coders/tuple.ts new file mode 100644 index 000000000..4eb94f875 --- /dev/null +++ b/src.ts/abi/coders/tuple.ts @@ -0,0 +1,66 @@ +import { defineProperties } from "../../utils/properties.js"; + +import { Typed } from "../typed.js"; +import { Coder } from "./abstract-coder.js"; + +import { pack, unpack } from "./array.js"; + +import type { Reader, Writer } from "./abstract-coder.js"; + +export class TupleCoder extends Coder { + readonly coders!: ReadonlyArray; + + constructor(coders: Array, localName: string) { + let dynamic = false; + const types: Array = []; + coders.forEach((coder) => { + if (coder.dynamic) { dynamic = true; } + types.push(coder.type); + }); + const type = ("tuple(" + types.join(",") + ")"); + + super("tuple", type, localName, dynamic); + defineProperties(this, { coders: Object.freeze(coders.slice()) }); + } + + defaultValue(): any { + const values: any = [ ]; + this.coders.forEach((coder) => { + values.push(coder.defaultValue()); + }); + + // We only output named properties for uniquely named coders + const uniqueNames = this.coders.reduce((accum, coder) => { + const name = coder.localName; + if (name) { + if (!accum[name]) { accum[name] = 0; } + accum[name]++; + } + return accum; + }, <{ [ name: string ]: number }>{ }); + + // Add named values + this.coders.forEach((coder: Coder, index: number) => { + let name = coder.localName; + if (!name || uniqueNames[name] !== 1) { return; } + + if (name === "length") { name = "_length"; } + + if (values[name] != null) { return; } + + values[name] = values[index]; + }); + + return Object.freeze(values); + } + + encode(writer: Writer, _value: Array | { [ name: string ]: any } | Typed): number { + const value = Typed.dereference(_value, "tuple"); + return pack(writer, this.coders, value); + } + + decode(reader: Reader): any { + return unpack(reader, this.coders); + } +} + diff --git a/src.ts/abi/fragments.ts b/src.ts/abi/fragments.ts new file mode 100644 index 000000000..c632a3010 --- /dev/null +++ b/src.ts/abi/fragments.ts @@ -0,0 +1,1091 @@ +import { logger } from "../utils/logger.js"; +import { defineProperties } from "../utils/index.js"; + + +export interface JsonFragmentType { + readonly name?: string; + readonly indexed?: boolean; + readonly type?: string; + readonly internalType?: string; + readonly components?: ReadonlyArray; +} + +export interface JsonFragment { + readonly name?: string; + readonly type?: string; + + readonly anonymous?: boolean; + + readonly payable?: boolean; + readonly constant?: boolean; + readonly stateMutability?: string; + + readonly inputs?: ReadonlyArray; + readonly outputs?: ReadonlyArray; + + readonly gas?: string; +}; + +export enum FormatType { + // Bare formatting, as is needed for computing a sighash of an event or function + sighash = "sighash", + + // Human-Readable with Minimal spacing and without names (compact human-readable) + minimal = "minimal", + + // Human-Readable with nice spacing, including all names + full = "full", + + // JSON-format a la Solidity + json = "json" +}; + +// [ "a", "b" ] => { "a": 1, "b": 1 } +function setify(items: Array): ReadonlySet { + const result: Set = new Set(); + items.forEach((k) => result.add(k)); + return Object.freeze(result); +} + +// Visibility Keywords +const _kwVisib = "constant external internal payable private public pure view"; +const KwVisib = setify(_kwVisib.split(" ")); + +const _kwTypes = "constructor error event function struct"; +const KwTypes = setify(_kwTypes.split(" ")); + +const _kwModifiers = "calldata memory storage payable indexed"; +const KwModifiers = setify(_kwModifiers.split(" ")); + +const _kwOther = "tuple returns"; + +// All Keywords +const _keywords = [ _kwTypes, _kwModifiers, _kwOther, _kwVisib ].join(" "); +const Keywords = setify(_keywords.split(" ")); + +// Single character tokens +const SimpleTokens: Record = { + "(": "OPEN_PAREN", ")": "CLOSE_PAREN", + "[": "OPEN_BRACKET", "]": "CLOSE_BRACKET", + ",": "COMMA", "@": "AT" +}; + +// Parser regexes to consume the next token +const regexWhitespace = new RegExp("^(\\s*)"); +const regexNumber = new RegExp("^([0-9]+)"); +const regexIdentifier = new RegExp("^([a-zA-Z$_][a-zA-Z0-9$_]*)"); +const regexType = new RegExp("^(address|bool|bytes([0-9]*)|string|u?int([0-9]*))"); + + +export type Token = Readonly<{ + // Type of token (e.g. TYPE, KEYWORD, NUMBER, etc) + type: string; + + // Offset into the original source code + offset: number; + + // Actual text content of the token + text: string; + + // The parenthesis depth + depth: number; + + // If a parenthesis, the offset (in tokens) that balances it + match: number; + + // For parenthesis and commas, the offset (in tokens) to the + // previous/next parenthesis or comma in the list + linkBack: number; + linkNext: number; + + // If a BRACKET, the value inside + value: number; +}>; + +export class TokenString { + #offset: number; + #tokens: ReadonlyArray; + + get offset(): number { return this.#offset; } + get length(): number { return this.#tokens.length - this.#offset; } + + constructor(tokens: ReadonlyArray) { + this.#offset = 0; + this.#tokens = tokens.slice(); + } + + clone(): TokenString { return new TokenString(this.#tokens); } + reset(): void { this.#offset = 0; } + + #subTokenString(from: number = 0, to: number = 0): TokenString { + return new TokenString(this.#tokens.slice(from, to).map((t) => { + return Object.freeze(Object.assign({ }, t, { + match: (t.match - from), + linkBack: (t.linkBack - from), + linkNext: (t.linkNext - from), + })); + return t; + })); + } + + // Pops and returns the value of the next token, if it is a keyword in allowed; throws if out of tokens + popKeyword(allowed: ReadonlySet): string { + const top = this.peek(); + if (top.type !== "KEYWORD" || !allowed.has(top.text)) { throw new Error(`expected keyword ${ top.text }`); } + return this.pop().text; + } + + // Pops and returns the value of the next token if it is `type`; throws if out of tokens + popType(type: string): string { + if (this.peek().type !== type) { throw new Error(`expected ${ type }; got ${ JSON.stringify(this.peek()) }`); } + return this.pop().text; + } + + // Pops and returns a "(" TOKENS ")" + popParen(): TokenString { + const top = this.peek(); + if (top.type !== "OPEN_PAREN") { throw new Error("bad start"); } + const result = this.#subTokenString(this.#offset + 1, top.match + 1); + this.#offset = top.match + 1; + return result; + } + + // Pops and returns the items within "(" ITEM1 "," ITEM2 "," ... ")" + popParams(): Array { + const top = this.peek(); + + if (top.type !== "OPEN_PAREN") { throw new Error("bad start"); } + + const result: Array = [ ]; + + while(this.#offset < top.match - 1) { + const link = this.peek().linkNext; + result.push(this.#subTokenString(this.#offset + 1, link)); + this.#offset = link; + } + + this.#offset = top.match + 1; + + return result; + } + + // Returns the top Token, throwing if out of tokens + peek(): Token { + if (this.#offset >= this.#tokens.length) { + throw new Error("out-of-bounds"); + } + return this.#tokens[this.#offset]; + } + + // Returns the next value, if it is a keyword in `allowed` + peekKeyword(allowed: ReadonlySet): null | string { + const top = this.peekType("KEYWORD"); + return (top != null && allowed.has(top)) ? top: null; + } + + // Returns the value of the next token if it is `type` + peekType(type: string): null | string { + if (this.length === 0) { return null; } + const top = this.peek(); + return (top.type === type) ? top.text: null; + } + + // Returns the next token; throws if out of tokens + pop(): Token { + const result = this.peek(); + this.#offset++; + return result; + } + + toString(): string { + const tokens: Array = [ ]; + for (let i = this.#offset; i < this.#tokens.length; i++) { + const token = this.#tokens[i]; + tokens.push(`${ token.type }:${ token.text }`); + } + return `` + } +} + +type Writeable = { -readonly [P in keyof T]: T[P] }; + +export function lex(text: string): TokenString { + const tokens: Array = [ ]; + + const throwError = (message: string) => { + const token = (offset < text.length) ? JSON.stringify(text[offset]): "$EOI"; + throw new Error(`invalid token ${ token } at ${ offset }: ${ message }`); + }; + + let brackets: Array = [ ]; + let commas: Array = [ ]; + + let offset = 0; + while (offset < text.length) { + + // Strip off any leading whitespace + let cur = text.substring(offset); + let match = cur.match(regexWhitespace); + if (match) { + offset += match[1].length; + cur = text.substring(offset); + } + + const token = { depth: brackets.length, linkBack: -1, linkNext: -1, match: -1, type: "", text: "", offset, value: -1 }; + tokens.push(token); + + let type = (SimpleTokens[cur[0]] || ""); + if (type) { + token.type = type; + token.text = cur[0]; + offset++; + + if (type === "OPEN_PAREN") { + brackets.push(tokens.length - 1); + commas.push(tokens.length - 1); + + } else if (type == "CLOSE_PAREN") { + if (brackets.length === 0) { throwError("no matching open bracket"); } + + token.match = brackets.pop() as number; + (>(tokens[token.match])).match = tokens.length - 1; + token.depth--; + + token.linkBack = commas.pop() as number; + (>(tokens[token.linkBack])).linkNext = tokens.length - 1; + + } else if (type === "COMMA") { + token.linkBack = commas.pop() as number; + (>(tokens[token.linkBack])).linkNext = tokens.length - 1; + commas.push(tokens.length - 1); + + } else if (type === "OPEN_BRACKET") { + token.type = "BRACKET"; + + } else if (type === "CLOSE_BRACKET") { + // Remove the CLOSE_BRACKET + let suffix = (tokens.pop() as Token).text; + if (tokens.length > 0 && tokens[tokens.length - 1].type === "NUMBER") { + const value = (tokens.pop() as Token).text; + suffix = value + suffix; + (>(tokens[tokens.length - 1])).value = logger.getNumber(value); + } + if (tokens.length === 0 || tokens[tokens.length - 1].type !== "BRACKET") { + throw new Error("missing opening bracket"); + } + (>(tokens[tokens.length - 1])).text += suffix; + } + + continue; + } + + match = cur.match(regexIdentifier); + if (match) { + token.text = match[1]; + offset += token.text.length; + + if (Keywords.has(token.text)) { + token.type = "KEYWORD"; + continue; + } + + if (token.text.match(regexType)) { + token.type = "TYPE"; + continue; + } + + token.type = "ID"; + continue; + } + + match = cur.match(regexNumber); + if (match) { + token.text = match[1]; + token.type = "NUMBER"; + offset += token.text.length; + continue; + } + + throw new Error(`unexpected token ${ JSON.stringify(cur[0]) } at position ${ offset }`); + } + + return new TokenString(tokens.map((t) => Object.freeze(t))); +} + +// Check only one of `allowed` is in `set` +function allowSingle(set: ReadonlySet, allowed: ReadonlySet): void { + let included: Array = [ ]; + for (const key in allowed.keys()) { + if (set.has(key)) { included.push(key); } + } + if (included.length > 1) { throw new Error(`conflicting types: ${ included.join(", ") }`); } +} + +// Functions to process a Solidity Signature TokenString from left-to-right for... + +// ...the name with an optional type, returning the name +function consumeName(type: string, tokens: TokenString): string { + if (tokens.peekKeyword(KwTypes)) { + const keyword = tokens.pop().text; + if (keyword !== type) { + throw new Error(`expected ${ type }, got ${ keyword }`); + } + } + + return tokens.popType("ID"); +} + +// ...all keywords matching allowed, returning the keywords +function consumeKeywords(tokens: TokenString, allowed?: ReadonlySet): ReadonlySet { + const keywords: Set = new Set(); + while (true) { + const keyword = tokens.peekType("KEYWORD"); + + if (keyword == null || (allowed && !allowed.has(keyword))) { break; } + tokens.pop(); + + if (keywords.has(keyword)) { throw new Error(`duplicate keywords: ${ JSON.stringify(keyword) }`); } + keywords.add(keyword); + } + + return Object.freeze(keywords); +} + +// ...all visibility keywords, returning the coalesced mutability +function consumeMutability(tokens: TokenString): string { + let modifiers = consumeKeywords(tokens, KwVisib); + + // Detect conflicting modifiers + allowSingle(modifiers, setify("constant payable nonpayable".split(" "))); + allowSingle(modifiers, setify("pure view payable nonpayable".split(" "))); + + // Process mutability states + if (modifiers.has("view")) { return "view"; } + if (modifiers.has("pure")) { return "pure"; } + if (modifiers.has("payable")) { return "payable"; } + if (modifiers.has("nonpayable")) { return "nonpayable"; } + + // Process legacy `constant` last + if (modifiers.has("constant")) { return "view"; } + + return "nonpayable"; +} + +// ...a parameter list, returning the ParamType list +function consumeParams(tokens: TokenString, allowIndexed?: boolean): Array { + return tokens.popParams().map((t) => ParamType.fromTokens(t, allowIndexed)); +} + +// ...a gas limit, returning a BigNumber or null if none +function consumeGas(tokens: TokenString): null | bigint { + if (tokens.peekType("AT")) { + tokens.pop(); + if (tokens.peekType("NUMBER")) { + return logger.getBigInt(tokens.pop().text); + } + throw new Error("invalid gas"); + } + return null; +} + +function consumeEoi(tokens: TokenString): void { + if (tokens.length) { + throw new Error(`unexpected tokens: ${ tokens.toString() }`); + } +} + +const regexArrayType = new RegExp(/^(.*)\[([0-9]*)\]$/); + +function verifyBasicType(type: string): string { + const match = type.match(regexType); + if (!match) { + return logger.throwArgumentError("invalid type", "type", type); + } + if (type === "uint") { return "uint256"; } + if (type === "int") { return "int256"; } + + if (match[2]) { + // bytesXX + const length = parseInt(match[2]); + if (length === 0 || length > 32) { + logger.throwArgumentError("invalid bytes length", "type", type); + } + + } else if (match[3]) { + // intXX or uintXX + const size = parseInt(match[3] as string); + if (size === 0 || size > 256 || size % 8) { + logger.throwArgumentError("invalid numeric width", "type", type); + } + } + + return type; +} + +// Make the Fragment constructors effectively private +const _guard = { }; + +export interface ArrayParamType { //extends ParamType { + readonly arrayLength: number; + readonly arrayChildren: ParamType; +} + +export interface TupleParamType extends ParamType { + readonly components: ReadonlyArray; +} + +export interface IndexableParamType extends ParamType { + readonly indexed: boolean; +} + +export type FragmentWalkFunc = (type: string, value: any) => any; +export type FragmentWalkAsyncFunc = (type: string, value: any) => any | Promise; + +const internal = Symbol.for("_ethers_internal"); +const ParamTypeInternal = "_ParamTypeInternal"; + +export class ParamType { + + // The local name of the parameter (of "" if unbound) + readonly name!: string; + + // The fully qualified type (e.g. "address", "tuple(address)", "uint256[3][]" + readonly type!: string; + + // The base type (e.g. "address", "tuple", "array") + readonly baseType!: string; + + // Indexable Paramters ONLY (otherwise null) + readonly indexed!: null | boolean; + + // Tuples ONLY: (otherwise null) + // - sub-components + readonly components!: null | ReadonlyArray; + + // Arrays ONLY: (otherwise null) + // - length of the array (-1 for dynamic length) + // - child type + readonly arrayLength!: null | number; + readonly arrayChildren!: null | ParamType; + + + constructor(guard: any, name: string, type: string, baseType: string, indexed: null | boolean, components: null | ReadonlyArray, arrayLength: null | number, arrayChildren: null | ParamType) { + logger.assertPrivate(guard, _guard, "ParamType"); + Object.defineProperty(this, internal, { value: ParamTypeInternal }); + + if (components) { components = Object.freeze(components.slice()); } + + if (baseType === "array") { + if (arrayLength == null || arrayChildren == null) { + throw new Error(""); + } + } else if (arrayLength != null || arrayChildren != null) { + throw new Error(""); + } + + if (baseType === "tuple") { + if (components == null) { throw new Error(""); } + } else if (components != null) { + throw new Error(""); + } + + defineProperties(this, { + name, type, baseType, indexed, components, arrayLength, arrayChildren + }); + } + + // Format the parameter fragment + // - sighash: "(uint256,address)" + // - minimal: "tuple(uint256,address) indexed" + // - full: "tuple(uint256 foo, address bar) indexed baz" + format(format: FormatType = FormatType.sighash): string { + if (!FormatType[format]) { + logger.throwArgumentError("invalid format type", "format", format); + } + + if (format === FormatType.json) { + let result: any = { + type: ((this.baseType === "tuple") ? "tuple": this.type), + name: (this.name || undefined) + }; + if (typeof(this.indexed) === "boolean") { result.indexed = this.indexed; } + if (this.isTuple()) { + result.components = this.components.map((c) => JSON.parse(c.format(format))); + } + return JSON.stringify(result); + } + + let result = ""; + + // Array + if (this.isArray()) { + result += this.arrayChildren.format(format); + result += `[${ (this.arrayLength < 0 ? "": String(this.arrayLength)) }]`; + } else { + if (this.isTuple()) { + if (format !== FormatType.sighash) { result += this.type; } + result += "(" + this.components.map( + (comp) => comp.format(format) + ).join((format === FormatType.full) ? ", ": ",") + ")"; + } else { + result += this.type; + } + } + + if (format !== FormatType.sighash) { + if (this.indexed === true) { result += " indexed"; } + if (format === FormatType.full && this.name) { + result += " " + this.name; + } + } + + return result; + } + + static isArray(value: any): value is { arrayChildren: ParamType } { + return value && (value.baseType === "array") + } + + isArray(): this is (ParamType & ArrayParamType) { + return (this.baseType === "array") + } + + isTuple(): this is TupleParamType { + return (this.baseType === "tuple"); + } + + isIndexable(): this is IndexableParamType { + return (this.indexed != null); + } + + walk(value: any, process: FragmentWalkFunc): any { + if (this.isArray()) { + if (!Array.isArray(value)) { throw new Error("invlaid array value"); } + if (this.arrayLength !== -1 && value.length !== this.arrayLength) { + throw new Error("array is wrong length"); + } + return value.map((v) => ((this).arrayChildren.walk(v, process))); + } + + if (this.isTuple()) { + if (!Array.isArray(value)) { throw new Error("invlaid tuple value"); } + if (value.length !== this.components.length) { + throw new Error("array is wrong length"); + } + return value.map((v, i) => ((this).components[i].walk(v, process))); + } + + return process(this.type, value); + } + + #walkAsync(promises: Array>, value: any, process: FragmentWalkAsyncFunc, setValue: (value: any) => void): void { + + if (this.isArray()) { + if (!Array.isArray(value)) { throw new Error("invlaid array value"); } + if (this.arrayLength !== -1 && value.length !== this.arrayLength) { + throw new Error("array is wrong length"); + } + const childType = this.arrayChildren; + + const result = value.slice(); + result.forEach((value, index) => { + childType.#walkAsync(promises, value, process, (value: any) => { + result[index] = value; + }); + }); + setValue(result); + return; + } + + if (this.isTuple()) { + const components = this.components; + + // Convert the object into an array + let result: Array; + if (Array.isArray(value)) { + result = value.slice(); + + } else { + if (value == null || typeof(value) !== "object") { + throw new Error("invlaid tuple value"); + } + + result = components.map((param) => { + if (!param.name) { throw new Error("cannot use object value with unnamed components"); } + if (!(param.name in value)) { + throw new Error(`missing value for component ${ param.name }`); + } + return value[param.name]; + }); + } + if (value.length !== this.components.length) { + throw new Error("array is wrong length"); + } + + result.forEach((value, index) => { + components[index].#walkAsync(promises, value, process, (value: any) => { + result[index] = value; + }); + }); + setValue(result); + return; + } + + const result = process(this.type, value); + if (result.then) { + promises.push((async function() { setValue(await result); })()); + } else { + setValue(result); + } + } + + async walkAsync(value: any, process: (type: string, value: any) => any | Promise): Promise { + const promises: Array> = [ ]; + const result: [ any ] = [ value ]; + this.#walkAsync(promises, value, process, (value: any) => { + result[0] = value; + }); + if (promises.length) { await Promise.all(promises); } + return result[0]; + } + + static from(obj: any, allowIndexed?: boolean): ParamType { + if (ParamType.isParamType(obj)) { return obj; } + if (typeof(obj) === "string") { return ParamType.fromTokens(lex(obj), allowIndexed); } + if (obj instanceof TokenString) { return ParamType.fromTokens(obj, allowIndexed); } + + const name = obj.name; + if (name && (typeof(name) !== "string" || !name.match(regexIdentifier))) { + logger.throwArgumentError("invalid name", "obj.name", name); + } + + let indexed = obj.indexed; + if (indexed != null) { + if (!allowIndexed) { + logger.throwArgumentError("parameter cannot be indexed", "obj.indexed", obj.indexed); + } + indexed = !!indexed; + } + + let type = obj.type; + + let arrayMatch = type.match(regexArrayType); + if (arrayMatch) { + const arrayLength = arrayMatch[2]; + const arrayChildren = ParamType.from({ + type: arrayMatch[1], + components: obj.components + }); + + return new ParamType(_guard, name, type, "array", indexed, null, arrayLength, arrayChildren); + } + + if (type.substring(0, 5) === "tuple(" || type[0] === "(") { + const comps = (obj.components != null) ? obj.components.map((c: any) => ParamType.from(c)): null; + const tuple = new ParamType(_guard, name, type, "tuple", indexed, comps, null, null); + // @TODO: use lexer to validate and normalize type + return tuple; + } + + type = verifyBasicType(obj.type); + + return new ParamType(_guard, name, type, type, indexed, null, null, null); + } + + static fromObject(obj: any, allowIndexed?: boolean): ParamType { + throw new Error("@TODO"); + } + + static fromTokens(tokens: TokenString, allowIndexed?: boolean): ParamType { + let type = "", baseType = ""; + let comps: null | Array = null; + + if (consumeKeywords(tokens, setify([ "tuple" ])).has("tuple") || tokens.peekType("OPEN_PAREN")) { + // Tuple + baseType = "tuple"; + comps = tokens.popParams().map((t) => ParamType.from(t)); + type = `tuple(${ comps.map((c) => c.format()).join(",") })`; + } else { + // Normal + type = verifyBasicType(tokens.popType("TYPE")); + baseType = type; + } + + // Check for Array + let arrayChildren: null | ParamType = null; + let arrayLength: null | number = null; + + while (tokens.length && tokens.peekType("BRACKET")) { + const bracket = tokens.pop(); //arrays[i]; + arrayChildren = new ParamType(_guard, "", type, baseType, null, comps, arrayLength, arrayChildren); + arrayLength = bracket.value; + type += bracket.text; + baseType = "array"; + comps = null; + } + + let indexed = null; + const keywords = consumeKeywords(tokens, KwModifiers); + if (keywords.has("indexed")) { + if (!allowIndexed) { throw new Error(""); } + indexed = true; + } + + const name = (tokens.peekType("ID") ? tokens.pop().text: ""); + + if (tokens.length) { throw new Error("leftover tokens"); } + + return new ParamType(_guard, name, type, baseType, indexed, comps, arrayLength, arrayChildren); + } + + static isParamType(value: any): value is ParamType { + return (value && value[internal] === ParamTypeInternal); + } +} + +export enum FragmentType { + "constructor" = "constructor", + "error" = "error", + "event" = "event", + "function" = "function", + "struct" = "struct", +}; + +export abstract class Fragment { + readonly type!: FragmentType; + readonly inputs!: ReadonlyArray; + + constructor(guard: any, type: FragmentType, inputs: ReadonlyArray) { + logger.assertPrivate(guard, _guard, "Fragment"); + inputs = Object.freeze(inputs.slice()); + defineProperties(this, { type, inputs }); + } + + abstract format(format?: FormatType): string; + + static from(obj: any): Fragment { + if (typeof(obj) === "string") { return this.fromString(obj); } + if (obj instanceof TokenString) { return this.fromTokens(obj); } + if (typeof(obj) === "object") { return this.fromObject(obj); } + throw new Error(`unsupported type: ${ obj }`); + } + + static fromObject(obj: any): Fragment { + switch (obj.type) { + case "constructor": return ConstructorFragment.fromObject(obj); + case "error": return ErrorFragment.fromObject(obj); + case "event": return EventFragment.fromObject(obj); + case "function": return FunctionFragment.fromObject(obj); + case "struct": return StructFragment.fromObject(obj); + } + throw new Error("not implemented yet"); + } + + static fromString(text: string): Fragment { + try { + Fragment.from(JSON.parse(text)); + } catch (e) { } + + return Fragment.fromTokens(lex(text)); + } + + static fromTokens(tokens: TokenString): Fragment { + const type = tokens.popKeyword(KwTypes); + + switch (type) { + case "constructor": return ConstructorFragment.fromTokens(tokens); + case "error": return ErrorFragment.fromTokens(tokens); + case "event": return EventFragment.fromTokens(tokens); + case "function": return FunctionFragment.fromTokens(tokens); + case "struct": return StructFragment.fromTokens(tokens); + } + + throw new Error(`unsupported type: ${ type }`); + } + + /* + static fromTokens(tokens: TokenString): Fragment { + const assertDone = () => { + if (tokens.length) { throw new Error(`unexpected tokens: ${ tokens.toString() }`); } + }); + + const type = (tokens.length && tokens.peek().type === "KEYWORD") ? tokens.peek().text: "unknown"; + + const name = consumeName("error", tokens); + const inputs = consumeParams(tokens, type === "event"); + + switch (type) { + case "event": case "struct": + assertDone(); + } + + } + */ + + static isConstructor(value: any): value is ConstructorFragment { + return (value && value.type === "constructor"); + } + + static isError(value: any): value is ErrorFragment { + return (value && value.type === "error"); + } + + static isEvent(value: any): value is EventFragment { + return (value && value.type === "event"); + } + + static isFunction(value: any): value is FunctionFragment { + return (value && value.type === "function"); + } + + static isStruct(value: any): value is StructFragment { + return (value && value.type === "struct"); + } +} + +export abstract class NamedFragment extends Fragment { + readonly name!: string; + + constructor(guard: any, type: FragmentType, name: string, inputs: ReadonlyArray) { + super(guard, type, inputs); + inputs = Object.freeze(inputs.slice()); + defineProperties(this, { name }); + } +} + +function joinParams(format: FormatType, params: ReadonlyArray): string { + return "(" + params.map((p) => p.format(format)).join((format === FormatType.full) ? ", ": ",") + ")"; +} + +export class ErrorFragment extends NamedFragment { + constructor(guard: any, name: string, inputs: ReadonlyArray) { + super(guard, FragmentType.error, name, inputs); + } + + format(format: FormatType = FormatType.sighash): string { + if (!FormatType[format]) { + logger.throwArgumentError("invalid format type", "format", format); + } + + if (format === FormatType.json) { + return JSON.stringify({ + type: "error", + name: this.name, + inputs: this.inputs.map((input) => JSON.parse(input.format(format))), + }); + } + + const result = [ ]; + if (format !== FormatType.sighash) { result.push("error"); } + result.push(this.name + joinParams(format, this.inputs)); + return result.join(" "); + } + + static fromString(text: string): ErrorFragment { + return ErrorFragment.fromTokens(lex(text)); + } + + static fromTokens(tokens: TokenString): ErrorFragment { + const name = consumeName("error", tokens); + const inputs = consumeParams(tokens); + consumeEoi(tokens); + + return new ErrorFragment(_guard, name, inputs); + } +} + + +export class EventFragment extends NamedFragment { + readonly anonymous!: boolean; + + constructor(guard: any, name: string, inputs: ReadonlyArray, anonymous: boolean) { + super(guard, FragmentType.event, name, inputs); + defineProperties(this, { anonymous }); + } + + format(format: FormatType = FormatType.sighash): string { + if (!FormatType[format]) { + logger.throwArgumentError("invalid format type", "format", format); + } + + if (format === FormatType.json) { + return JSON.stringify({ + type: "event", + anonymous: this.anonymous, + name: this.name, + inputs: this.inputs.map((i) => JSON.parse(i.format(format))) + }); + } + + const result = [ ]; + if (format !== FormatType.sighash) { result.push("event"); } + result.push(this.name + joinParams(format, this.inputs)); + if (format !== FormatType.sighash && this.anonymous) { result.push("anonymous"); } + return result.join(" "); + } + + static fromString(text: string): EventFragment { + return EventFragment.fromTokens(lex(text)); + } + + static fromTokens(tokens: TokenString): EventFragment { + const name = consumeName("event", tokens); + const inputs = consumeParams(tokens, true); + const anonymous = !!consumeKeywords(tokens, setify([ "anonymous" ])).has("anonymous"); + consumeEoi(tokens); + + return new EventFragment(_guard, name, inputs, anonymous); + } +} + + +export class ConstructorFragment extends Fragment { + readonly payable!: boolean; + readonly gas!: null | bigint; + + constructor(guard: any, type: FragmentType, inputs: ReadonlyArray, payable: boolean, gas: null | bigint) { + super(guard, type, inputs); + defineProperties(this, { payable, gas }); + } + + format(format: FormatType = FormatType.sighash): string { + if (!FormatType[format]) { + logger.throwArgumentError("invalid format type", "format", format); + } + + if (format === FormatType.sighash) { + logger.throwError("cannot format a constructor for sighash", "UNSUPPORTED_OPERATION", { + operation: "format(sighash)" + }); + } + + if (format === FormatType.json) { + return JSON.stringify({ + type: "constructor", + stateMutability: (this.payable ? "payable": "undefined"), + payable: this.payable, + gas: ((this.gas != null) ? this.gas: undefined), + inputs: this.inputs.map((i) => JSON.parse(i.format(format))) + }); + } + + const result = [ `constructor${ joinParams(format, this.inputs) }` ]; + result.push((this.payable) ? "payable": "nonpayable"); + if (this.gas != null) { result.push(`@${ this.gas.toString() }`); } + return result.join(" "); + } + + static fromString(text: string): ConstructorFragment { + return ConstructorFragment.fromTokens(lex(text)); + } + + static fromObject(obj: any): ConstructorFragment { + throw new Error("TODO"); + } + + static fromTokens(tokens: TokenString): ConstructorFragment { + consumeKeywords(tokens, setify([ "constructor" ])); + const inputs = consumeParams(tokens); + const payable = !!consumeKeywords(tokens, setify([ "payable" ])).has("payable"); + const gas = consumeGas(tokens); + consumeEoi(tokens); + + return new ConstructorFragment(_guard, FragmentType.constructor, inputs, payable, gas); + } +} + +export class FunctionFragment extends NamedFragment { + readonly constant!: boolean; + readonly outputs!: ReadonlyArray; + readonly stateMutability!: string; + + readonly payable!: boolean; + readonly gas!: null | bigint; + + constructor(guard: any, name: string, stateMutability: string, inputs: ReadonlyArray, outputs: ReadonlyArray, gas: null | bigint) { + super(guard, FragmentType.function, name, inputs); + outputs = Object.freeze(outputs.slice()); + const constant = (stateMutability === "view" || stateMutability === "pure"); + const payable = (stateMutability === "payable"); + defineProperties(this, { constant, gas, outputs, payable, stateMutability }); + } + + format(format: FormatType = FormatType.sighash): string { + if (!FormatType[format]) { + logger.throwArgumentError("invalid format type", "format", format); + } + + if (format === FormatType.json) { + return JSON.stringify({ + type: "function", + name: this.name, + constant: this.constant, + stateMutability: ((this.stateMutability !== "nonpayable") ? this.stateMutability: undefined), + payable: this.payable, + gas: ((this.gas != null) ? this.gas: undefined), + inputs: this.inputs.map((i) => JSON.parse(i.format(format))), + outputs: this.outputs.map((o) => JSON.parse(o.format(format))), + }); + } + + const result = []; + + if (format !== FormatType.sighash) { result.push("function"); } + + result.push(this.name + joinParams(format, this.inputs)); + + if (format !== FormatType.sighash) { + if (this.stateMutability !== "nonpayable") { + result.push(this.stateMutability); + } + + if (this.outputs && this.outputs.length) { + result.push("returns"); + result.push(joinParams(format, this.outputs)); + } + + if (this.gas != null) { result.push(`@${ this.gas.toString() }`); } + } + return result.join(" "); + } + + static fromString(text: string): FunctionFragment { + return FunctionFragment.fromTokens(lex(text)); + } + + static fromTokens(tokens: TokenString): FunctionFragment { + const name = consumeName("function", tokens); + const inputs = consumeParams(tokens); + const mutability = consumeMutability(tokens); + + let outputs: Array = [ ]; + if (consumeKeywords(tokens, setify([ "returns" ])).has("returns")) { + outputs = consumeParams(tokens); + } + + const gas = consumeGas(tokens); + + consumeEoi(tokens); + + return new FunctionFragment(_guard, name, mutability, inputs, outputs, gas); + } +} + +export class StructFragment extends NamedFragment { + format(): string { + throw new Error("@TODO"); + } + + static fromString(text: string): StructFragment { + return StructFragment.fromTokens(lex(text)); + } + + static fromTokens(tokens: TokenString): StructFragment { + const name = consumeName("struct", tokens); + const inputs = consumeParams(tokens); + consumeEoi(tokens); + + return new StructFragment(_guard, FragmentType.struct, name, inputs); + } +} + diff --git a/src.ts/abi/index.ts b/src.ts/abi/index.ts new file mode 100644 index 000000000..333cd0c12 --- /dev/null +++ b/src.ts/abi/index.ts @@ -0,0 +1,38 @@ + +export { + AbiCoder, + defaultAbiCoder +} from "./abi-coder.js"; + +export { formatBytes32String, parseBytes32String } from "./bytes32.js"; + +export { + ConstructorFragment, + ErrorFragment, + EventFragment, + Fragment, + FunctionFragment, + ParamType +} from "./fragments.js"; + +export { + checkResultErrors, + Indexed, + Interface, + LogDescription, + Result, + TransactionDescription +} from "./interface.js"; + +export { Typed } from "./typed.js"; + +export type { + JsonFragment, + JsonFragmentType, +} from "./fragments.js"; + + +export type { + InterfaceAbi, +} from "./interface.js"; + diff --git a/src.ts/abi/interface.ts b/src.ts/abi/interface.ts new file mode 100644 index 000000000..3946f4819 --- /dev/null +++ b/src.ts/abi/interface.ts @@ -0,0 +1,905 @@ +import { concat, dataSlice, hexlify, zeroPadValue, isHexString } from "../utils/data.js"; +import { keccak256 } from "../crypto/index.js" +import { id } from "../hash/index.js" +import { logger } from "../utils/logger.js"; +import { defineProperties } from "../utils/properties.js"; +import { toHex } from "../utils/maths.js"; + +import { AbiCoder, defaultAbiCoder } from "./abi-coder.js"; +import { checkResultErrors, Result } from "./coders/abstract-coder.js"; +import { ConstructorFragment, ErrorFragment, EventFragment, FormatType, Fragment, FunctionFragment, ParamType } from "./fragments.js"; +import { Typed } from "./typed.js"; + +import type { BigNumberish, BytesLike } from "../utils/index.js"; + +import type { JsonFragment } from "./fragments.js"; + + +export { checkResultErrors, Result }; + +export class LogDescription { + readonly fragment!: EventFragment; + readonly name!: string; + readonly signature!: string; + readonly topic!: string; + readonly args!: Result + + constructor(fragment: EventFragment, topic: string, args: Result) { + const name = fragment.name, signature = fragment.format(); + defineProperties(this, { + fragment, name, signature, topic, args + }); + } +} + +export class TransactionDescription { + readonly fragment!: FunctionFragment; + readonly name!: string; + readonly args!: Result; + readonly signature!: string; + readonly selector!: string; + readonly value!: bigint; + + constructor(fragment: FunctionFragment, selector: string, args: Result, value: bigint) { + const name = fragment.name, signature = fragment.format(); + defineProperties(this, { + fragment, name, args, signature, selector, value + }); + } +} + +export class ErrorDescription { + readonly fragment!: ErrorFragment; + readonly name!: string; + readonly args!: Result; + readonly signature!: string; + readonly selector!: string; + + constructor(fragment: ErrorFragment, selector: string, args: Result) { + const name = fragment.name, signature = fragment.format(); + defineProperties(this, { + fragment, name, args, signature, selector + }); + } +} + +export class Indexed { + readonly hash!: null | string; + readonly _isIndexed!: boolean; + + static isIndexed(value: any): value is Indexed { + return !!(value && value._isIndexed); + } + + constructor(hash: null | string) { + defineProperties(this, { hash, _isIndexed: true }) + } +} + +type ErrorInfo = { + signature: string, + inputs: Array, + name: string, + reason: (...args: Array) => string; +}; + +// https://docs.soliditylang.org/en/v0.8.13/control-structures.html?highlight=panic#panic-via-assert-and-error-via-require +const PanicReasons: Record = { + "0": "generic panic", + "1": "assert(false)", + "17": "arithmetic overflow", + "18": "division or modulo by zero", + "33": "enum overflow", + "34": "invalid encoded storage byte array accessed", + "49": "out-of-bounds array access; popping on an empty array", + "50": "out-of-bounds access of an array or bytesN", + "65": "out of memory", + "81": "uninitialized function", +} + +const BuiltinErrors: Record = { + "0x08c379a0": { + signature: "Error(string)", + name: "Error", + inputs: [ "string" ], + reason: (message: string) => { + return `reverted with reason string ${ JSON.stringify(message) }`; + } + }, + "0x4e487b71": { + signature: "Panic(uint256)", + name: "Panic", + inputs: [ "uint256" ], + reason: (code: bigint) => { + let reason = "unknown panic code"; + if (code >= 0 && code <= 0xff && PanicReasons[code.toString()]) { + reason = PanicReasons[code.toString()]; + } + return `reverted with panic code 0x${ code.toString(16) } (${ reason })`; + } + } +} + +/* +function wrapAccessError(property: string, error: Error): Error { + const wrap = new Error(`deferred error during ABI decoding triggered accessing ${ property }`); + (wrap).error = error; + return wrap; +} +*/ +/* +function checkNames(fragment: Fragment, type: "input" | "output", params: Array): void { + params.reduce((accum, param) => { + if (param.name) { + if (accum[param.name]) { + logger.throwArgumentError(`duplicate ${ type } parameter ${ JSON.stringify(param.name) } in ${ fragment.format("full") }`, "fragment", fragment); + } + accum[param.name] = true; + } + return accum; + }, <{ [ name: string ]: boolean }>{ }); +} +*/ +//export type AbiCoder = any; +//const defaultAbiCoder: AbiCoder = { }; + +export type InterfaceAbi = string | ReadonlyArray; + +export class Interface { + readonly fragments!: ReadonlyArray; + + readonly deploy!: ConstructorFragment; + + #errors: Map; + #events: Map; + #functions: Map; +// #structs: Map; + + #abiCoder: AbiCoder; + + constructor(fragments: InterfaceAbi) { + let abi: ReadonlyArray = [ ]; + if (typeof(fragments) === "string") { + abi = JSON.parse(fragments); + } else { + abi = fragments; + } + + this.#functions = new Map(); + this.#errors = new Map(); + this.#events = new Map(); +// this.#structs = new Map(); + + defineProperties(this, { + fragments: Object.freeze(abi.map((f) => Fragment.from(f)).filter((f) => (f != null))), + }); + + this.#abiCoder = this.getAbiCoder(); + + // Add all fragments by their signature + this.fragments.forEach((fragment) => { + let bucket: Map; + switch (fragment.type) { + case "constructor": + if (this.deploy) { + logger.warn("duplicate definition - constructor"); + return; + } + //checkNames(fragment, "input", fragment.inputs); + defineProperties(this, { deploy: fragment }); + return; + + case "function": + //checkNames(fragment, "input", fragment.inputs); + //checkNames(fragment, "output", (fragment).outputs); + bucket = this.#functions; + break; + + case "event": + //checkNames(fragment, "input", fragment.inputs); + bucket = this.#events; + break; + + case "error": + bucket = this.#errors; + break; + + default: + return; + } + + const signature = fragment.format(); + if (bucket.has(signature)) { + logger.warn("duplicate definition - " + signature); + return; + } + + bucket.set(signature, fragment); + }); + + // If we do not have a constructor add a default + if (!this.deploy) { + defineProperties(this, { + deploy: ConstructorFragment.fromString("constructor()") + }); + } + } +// @TODO: multi sig? + format(format?: FormatType): string | Array { + if (!format) { format = FormatType.full; } + if (format === FormatType.sighash) { + logger.throwArgumentError("interface does not support formatting sighash", "format", format); + } + + const abi = this.fragments.map((f) => f.format(format)); + + // We need to re-bundle the JSON fragments a bit + if (format === FormatType.json) { + return JSON.stringify(abi.map((j) => JSON.parse(j))); + } + + return abi; + } + + getAbiCoder(): AbiCoder { + return defaultAbiCoder; + } + + //static getAddress(address: string): string { + // return getAddress(address); + //} + + //static getSelector(fragment: ErrorFragment | FunctionFragment): string { + // return dataSlice(id(fragment.format()), 0, 4); + //} + + //static getEventTopic(eventFragment: EventFragment): string { + // return id(eventFragment.format()); + //} + + // Find a function definition by any means necessary (unless it is ambiguous) + #getFunction(key: string, values: null | Array, forceUnique: boolean): FunctionFragment { + + // Selector + if (isHexString(key)) { + const selector = key.toLowerCase(); + for (const fragment of this.#functions.values()) { + if (selector === this.getSelector(fragment)) { return fragment; } + } + logger.throwArgumentError("no matching function", "selector", key); + } + + // It is a bare name, look up the function (will return null if ambiguous) + if (key.indexOf("(") === -1) { + const matching: Array = [ ]; + for (const [ name, fragment ] of this.#functions) { + if (name.split("("/* fix:) */)[0] === key) { matching.push(fragment); } + } + + if (values) { + const lastValue = (values.length > 0) ? values[values.length - 1]: null; + + let valueLength = values.length; + let allowOptions = true; + if (Typed.isTyped(lastValue) && lastValue.type === "overrides") { + allowOptions = false; + valueLength--; + } + + // Remove all matches that don't have a compatible length. The args + // may contain an overrides, so the match may have n or n - 1 parameters + for (let i = matching.length - 1; i >= 0; i--) { + const inputs = matching[i].inputs.length; + if (inputs !== valueLength && (!allowOptions || inputs !== valueLength - 1)) { + matching.splice(i, 1); + } + } + + // Remove all matches that don't match the Typed signature + for (let i = matching.length - 1; i >= 0; i--) { + const inputs = matching[i].inputs; + for (let j = 0; j < values.length; j++) { + // Not a typed value + if (!Typed.isTyped(values[j])) { continue; } + + // We are past the inputs + if (j >= inputs.length) { + if (values[j].type === "overrides") { continue; } + matching.splice(i, 1); + break; + } + + // Make sure the value type matches the input type + if (values[j].type !== inputs[j].baseType) { + matching.splice(i, 1); + break; + } + } + } + } + + // We found a single matching signature with an overrides, but the + // last value is something that cannot possibly be an options + if (matching.length === 1 && values && values.length !== matching[0].inputs.length) { + const lastArg = values[values.length - 1]; + if (lastArg == null || Array.isArray(lastArg) || typeof(lastArg) !== "object") { + matching.splice(0, 1); + } + } + + if (matching.length === 0) { + logger.throwArgumentError("no matching function", "name", key); + + } else if (matching.length > 1 && forceUnique) { + const matchStr = matching.map((m) => JSON.stringify(m.format())).join(", "); + logger.throwArgumentError(`multiple matching functions (i.e. ${ matchStr })`, "name", key); + } + + return matching[0]; + } + + // Normalize the signature and lookup the function + const result = this.#functions.get(FunctionFragment.fromString(key).format()); + if (result) { return result; } + + return logger.throwArgumentError("no matching function", "signature", key); + } + getFunctionName(key: string): string { + return (this.#getFunction(key, null, false)).name; + } + getFunction(key: string, values?: Array): FunctionFragment { + return this.#getFunction(key, values || null, true) + } + + + // Find an event definition by any means necessary (unless it is ambiguous) + #getEvent(key: string, values: null | Array, forceUnique: boolean): EventFragment { + + // EventTopic + if (isHexString(key)) { + const eventTopic = key.toLowerCase(); + for (const fragment of this.#events.values()) { + if (eventTopic === this.getEventTopic(fragment)) { return fragment; } + } + logger.throwArgumentError("no matching event", "eventTopic", key); + } + + // It is a bare name, look up the function (will return null if ambiguous) + if (key.indexOf("(") === -1) { + const matching = [ ]; + for (const [ name, fragment ] of this.#events) { + if (name.split("("/* fix:) */)[0] === key) { matching.push(fragment); } + } + + if (values) { + // Remove all matches that don't have a compatible length. + for (let i = matching.length - 1; i >= 0; i--) { + if (matching[i].inputs.length < values.length) { + matching.splice(i, 1); + } + } + + // Remove all matches that don't match the Typed signature + for (let i = matching.length - 1; i >= 0; i--) { + const inputs = matching[i].inputs; + for (let j = 0; j < values.length; j++) { + // Not a typed value + if (!Typed.isTyped(values[j])) { continue; } + + // Make sure the value type matches the input type + if (values[j].type !== inputs[j].baseType) { + matching.splice(i, 1); + break; + } + } + } + } + + if (matching.length === 0) { + logger.throwArgumentError("no matching event", "name", key); + } else if (matching.length > 1 && forceUnique) { + // @TODO: refine by Typed + logger.throwArgumentError("multiple matching events", "name", key); + } + + return matching[0]; + } + + // Normalize the signature and lookup the function + const result = this.#events.get(EventFragment.fromString(key).format()); + if (result) { return result; } + + return logger.throwArgumentError("no matching event", "signature", key); + } + getEventName(key: string): string { + return (this.#getEvent(key, null, false)).name; + } + getEvent(key: string, values?: Array): EventFragment { + return this.#getEvent(key, values || null, true) + } + + // Find a function definition by any means necessary (unless it is ambiguous) + getError(key: string, values?: Array): ErrorFragment { + if (isHexString(key)) { + const selector = key.toLowerCase(); + + if (BuiltinErrors[selector]) { + return ErrorFragment.fromString(BuiltinErrors[selector].signature); + } + + for (const fragment of this.#errors.values()) { + if (selector === this.getSelector(fragment)) { return fragment; } + } + logger.throwArgumentError("no matching error", "selector", key); + } + + // It is a bare name, look up the function (will return null if ambiguous) + if (key.indexOf("(") === -1) { + const matching = [ ]; + for (const [ name, fragment ] of this.#errors) { + if (name.split("("/* fix:) */)[0] === key) { matching.push(fragment); } + } + + if (matching.length === 0) { + if (key === "Error") { return ErrorFragment.fromString("error Error(string)"); } + if (key === "Panic") { return ErrorFragment.fromString("error Panic(uint256)"); } + logger.throwArgumentError("no matching error", "name", key); + } else if (matching.length > 1) { + // @TODO: refine by Typed + logger.throwArgumentError("multiple matching errors", "name", key); + } + + return matching[0]; + } + + // Normalize the signature and lookup the function + key = ErrorFragment.fromString(key).format() + if (key === "Error(string)") { return ErrorFragment.fromString("error Error(string)"); } + if (key === "Panic(uint256)") { return ErrorFragment.fromString("error Panic(uint256)"); } + + const result = this.#errors.get(key); + if (result) { return result; } + + return logger.throwArgumentError("no matching error", "signature", key); + } + + // Get the 4-byte selector used by Solidity to identify a function + getSelector(fragment: ErrorFragment | FunctionFragment): string { + /* + if (typeof(fragment) === "string") { + const matches: Array = [ ]; + + try { matches.push(this.getFunction(fragment)); } catch (error) { } + try { matches.push(this.getError(fragment)); } catch (_) { } + + if (matches.length === 0) { + logger.throwArgumentError("unknown fragment", "key", fragment); + } else if (matches.length > 1) { + logger.throwArgumentError("ambiguous fragment matches function and error", "key", fragment); + } + + fragment = matches[0]; + } + */ + + return dataSlice(id(fragment.format()), 0, 4); + } + + // Get the 32-byte topic hash used by Solidity to identify an event + getEventTopic(fragment: EventFragment): string { + //if (typeof(fragment) === "string") { fragment = this.getEvent(eventFragment); } + return id(fragment.format()); + } + + + _decodeParams(params: ReadonlyArray, data: BytesLike): Result { + return this.#abiCoder.decode(params, data) + } + + _encodeParams(params: ReadonlyArray, values: ReadonlyArray): string { + return this.#abiCoder.encode(params, values) + } + + encodeDeploy(values?: ReadonlyArray): string { + return this._encodeParams(this.deploy.inputs, values || [ ]); + } + + decodeErrorResult(fragment: ErrorFragment | string, data: BytesLike): Result { + if (typeof(fragment) === "string") { fragment = this.getError(fragment); } + + if (dataSlice(data, 0, 4) !== this.getSelector(fragment)) { + logger.throwArgumentError(`data signature does not match error ${ fragment.name }.`, "data", data); + } + + return this._decodeParams(fragment.inputs, dataSlice(data, 4)); + } + + encodeErrorResult(fragment: ErrorFragment | string, values?: ReadonlyArray): string { + if (typeof(fragment) === "string") { fragment = this.getError(fragment); } + + return concat([ + this.getSelector(fragment), + this._encodeParams(fragment.inputs, values || [ ]) + ]); + } + + // Decode the data for a function call (e.g. tx.data) + decodeFunctionData(fragment: FunctionFragment | string, data: BytesLike): Result { + if (typeof(fragment) === "string") { fragment = this.getFunction(fragment); } + + if (dataSlice(data, 0, 4) !== this.getSelector(fragment)) { + logger.throwArgumentError(`data signature does not match function ${ fragment.name }.`, "data", data); + } + + return this._decodeParams(fragment.inputs, dataSlice(data, 4)); + } + + // Encode the data for a function call (e.g. tx.data) + encodeFunctionData(fragment: FunctionFragment | string, values?: ReadonlyArray): string { + if (typeof(fragment) === "string") { fragment = this.getFunction(fragment); } + + return concat([ + this.getSelector(fragment), + this._encodeParams(fragment.inputs, values || [ ]) + ]); + } + + // Decode the result from a function call (e.g. from eth_call) + decodeFunctionResult(fragment: FunctionFragment | string, data: BytesLike): Result { + if (typeof(fragment) === "string") { fragment = this.getFunction(fragment); } + + let message = "invalid length for result data"; + + const bytes = logger.getBytesCopy(data); + if ((bytes.length % 32) === 0) { + try { + return this.#abiCoder.decode(fragment.outputs, bytes); + } catch (error) { + message = "could not decode result data"; + } + } + + // Call returned data with no error, but the data is junk + return logger.throwError(message, "BAD_DATA", { + value: hexlify(bytes), + info: { method: fragment.name, signature: fragment.format() } + }); + } + + makeError(fragment: FunctionFragment | string, _data: BytesLike, tx?: { data: string }): Error { + if (typeof(fragment) === "string") { fragment = this.getFunction(fragment); } + + const data = logger.getBytes(_data); + + let args: undefined | Result = undefined; + if (tx) { + try { + args = this.#abiCoder.decode(fragment.inputs, tx.data || "0x"); + } catch (error) { console.log(error); } + } + + let errorArgs: undefined | Result = undefined; + let errorName: undefined | string = undefined; + let errorSignature: undefined | string = undefined; + let reason: string = "unknown reason"; + + if (data.length === 0) { + reason = "missing error reason"; + + } else if ((data.length % 32) === 4) { + const selector = hexlify(data.slice(0, 4)); + const builtin = BuiltinErrors[selector]; + if (builtin) { + try { + errorName = builtin.name; + errorSignature = builtin.signature; + errorArgs = this.#abiCoder.decode(builtin.inputs, data.slice(4)); + reason = builtin.reason(...errorArgs); + } catch (error) { + console.log(error); // @TODO: remove + } + } else { + reason = "unknown custom error"; + try { + const error = this.getError(selector); + errorName = error.name; + errorSignature = error.format(); + reason = `custom error: ${ errorSignature }`; + try { + errorArgs = this.#abiCoder.decode(error.inputs, data.slice(4)); + } catch (error) { + reason = `custom error: ${ errorSignature } (coult not decode error data)` + } + } catch (error) { + console.log(error); // @TODO: remove + } + } + } + + return logger.makeError("call revert exception", "CALL_EXCEPTION", { + data: hexlify(data), transaction: null, + method: fragment.name, signature: fragment.format(), args, + errorArgs, errorName, errorSignature, reason + }); + } + + // Encode the result for a function call (e.g. for eth_call) + encodeFunctionResult(functionFragment: FunctionFragment | string, values?: ReadonlyArray): string { + if (typeof(functionFragment) === "string") { + functionFragment = this.getFunction(functionFragment); + } + + return hexlify(this.#abiCoder.encode(functionFragment.outputs, values || [ ])); + } +/* + spelunk(inputs: Array, values: ReadonlyArray, processfunc: (type: string, value: any) => Promise): Promise> { + const promises: Array> = [ ]; + const process = function(type: ParamType, value: any): any { + if (type.baseType === "array") { + return descend(type.child + } + if (type. === "address") { + } + }; + + const descend = function (inputs: Array, values: ReadonlyArray) { + if (inputs.length !== values.length) { throw new Error("length mismatch"); } + + }; + + const result: Array = [ ]; + values.forEach((value, index) => { + if (value == null) { + topics.push(null); + } else if (param.baseType === "array" || param.baseType === "tuple") { + logger.throwArgumentError("filtering with tuples or arrays not supported", ("contract." + param.name), value); + } else if (Array.isArray(value)) { + topics.push(value.map((value) => encodeTopic(param, value))); + } else { + topics.push(encodeTopic(param, value)); + } + }); + } +*/ + // Create the filter for the event with search criteria (e.g. for eth_filterLog) + encodeFilterTopics(eventFragment: EventFragment, values: ReadonlyArray): Array> { + if (typeof(eventFragment) === "string") { + eventFragment = this.getEvent(eventFragment); + } + + if (values.length > eventFragment.inputs.length) { + logger.throwError("too many arguments for " + eventFragment.format(), "UNEXPECTED_ARGUMENT", { + count: values.length, + expectedCount: eventFragment.inputs.length + }) + } + + const topics: Array> = []; + if (!eventFragment.anonymous) { topics.push(this.getEventTopic(eventFragment)); } + + // @TODO: Use the coders for this; to properly support tuples, etc. + const encodeTopic = (param: ParamType, value: any): string => { + if (param.type === "string") { + return id(value); + } else if (param.type === "bytes") { + return keccak256(hexlify(value)); + } + + if (param.type === "bool" && typeof(value) === "boolean") { + value = (value ? "0x01": "0x00"); + } + + if (param.type.match(/^u?int/)) { + value = toHex(value); + } + + // Check addresses are valid + if (param.type === "address") { this.#abiCoder.encode( [ "address" ], [ value ]); } + return zeroPadValue(hexlify(value), 32); + //@TOOD should probably be return toHex(value, 32) + }; + + values.forEach((value, index) => { + + const param = eventFragment.inputs[index]; + + if (!param.indexed) { + if (value != null) { + logger.throwArgumentError("cannot filter non-indexed parameters; must be null", ("contract." + param.name), value); + } + return; + } + + if (value == null) { + topics.push(null); + } else if (param.baseType === "array" || param.baseType === "tuple") { + logger.throwArgumentError("filtering with tuples or arrays not supported", ("contract." + param.name), value); + } else if (Array.isArray(value)) { + topics.push(value.map((value) => encodeTopic(param, value))); + } else { + topics.push(encodeTopic(param, value)); + } + }); + + // Trim off trailing nulls + while (topics.length && topics[topics.length - 1] === null) { + topics.pop(); + } + + return topics; + } + + encodeEventLog(eventFragment: EventFragment, values: ReadonlyArray): { data: string, topics: Array } { + if (typeof(eventFragment) === "string") { + eventFragment = this.getEvent(eventFragment); + } + + const topics: Array = [ ]; + + const dataTypes: Array = [ ]; + const dataValues: Array = [ ]; + + if (!eventFragment.anonymous) { + topics.push(this.getEventTopic(eventFragment)); + } + + if (values.length !== eventFragment.inputs.length) { + logger.throwArgumentError("event arguments/values mismatch", "values", values); + } + + eventFragment.inputs.forEach((param, index) => { + const value = values[index]; + if (param.indexed) { + if (param.type === "string") { + topics.push(id(value)) + } else if (param.type === "bytes") { + topics.push(keccak256(value)) + } else if (param.baseType === "tuple" || param.baseType === "array") { + // @TODO + throw new Error("not implemented"); + } else { + topics.push(this.#abiCoder.encode([ param.type] , [ value ])); + } + } else { + dataTypes.push(param); + dataValues.push(value); + } + }); + + return { + data: this.#abiCoder.encode(dataTypes , dataValues), + topics: topics + }; + } + + // Decode a filter for the event and the search criteria + decodeEventLog(eventFragment: EventFragment | string, data: BytesLike, topics?: ReadonlyArray): Result { + if (typeof(eventFragment) === "string") { + eventFragment = this.getEvent(eventFragment); + } + + if (topics != null && !eventFragment.anonymous) { + const eventTopic = this.getEventTopic(eventFragment); + if (!isHexString(topics[0], 32) || topics[0].toLowerCase() !== eventTopic) { + logger.throwArgumentError("fragment/topic mismatch", "topics[0]", topics[0]); + } + topics = topics.slice(1); + } + + const indexed: Array = []; + const nonIndexed: Array = []; + const dynamic: Array = []; + + eventFragment.inputs.forEach((param, index) => { + if (param.indexed) { + if (param.type === "string" || param.type === "bytes" || param.baseType === "tuple" || param.baseType === "array") { + indexed.push(ParamType.fromObject({ type: "bytes32", name: param.name })); + dynamic.push(true); + } else { + indexed.push(param); + dynamic.push(false); + } + } else { + nonIndexed.push(param); + dynamic.push(false); + } + }); + + const resultIndexed = (topics != null) ? this.#abiCoder.decode(indexed, concat(topics)): null; + const resultNonIndexed = this.#abiCoder.decode(nonIndexed, data, true); + + //const result: (Array & { [ key: string ]: any }) = [ ]; + const values: Array = [ ]; + const keys: Array = [ ]; + let nonIndexedIndex = 0, indexedIndex = 0; + eventFragment.inputs.forEach((param, index) => { + let value = null; + if (param.indexed) { + if (resultIndexed == null) { + value = new Indexed(null); + + } else if (dynamic[index]) { + value = new Indexed(resultIndexed[indexedIndex++]); + + } else { + try { + value = resultIndexed[indexedIndex++]; + } catch (error) { + value = error; + } + } + } else { + try { + value = resultNonIndexed[nonIndexedIndex++]; + } catch (error) { + value = error; + } + } + + values.push(value); + keys.push(param.name || null); + }); + + return Result.fromItems(values, keys); + } + + // Given a transaction, find the matching function fragment (if any) and + // determine all its properties and call parameters + parseTransaction(tx: { data: string, value?: BigNumberish }): null | TransactionDescription { + const data = logger.getBytes(tx.data, "tx.data"); + const value = logger.getBigInt((tx.value != null) ? tx.value: 0, "tx.value"); + + const fragment = this.getFunction(hexlify(data.slice(0, 4))); + + if (!fragment) { return null; } + + const args = this.#abiCoder.decode(fragment.inputs, data.slice(4)); + return new TransactionDescription(fragment, this.getSelector(fragment), args, value); + } + + // @TODO + //parseCallResult(data: BytesLike): ?? + + // Given an event log, find the matching event fragment (if any) and + // determine all its properties and values + parseLog(log: { topics: Array, data: string}): null | LogDescription { + const fragment = this.getEvent(log.topics[0]); + + if (!fragment || fragment.anonymous) { return null; } + + // @TODO: If anonymous, and the only method, and the input count matches, should we parse? + // Probably not, because just because it is the only event in the ABI does + // not mean we have the full ABI; maybe just a fragment? + + + return new LogDescription(fragment, this.getEventTopic(fragment), this.decodeEventLog(fragment, log.data, log.topics)); + } + + parseError(data: BytesLike): null | ErrorDescription { + const hexData = hexlify(data); + + const fragment = this.getError(dataSlice(hexData, 0, 4)); + + if (!fragment) { return null; } + + const args = this.#abiCoder.decode(fragment.inputs, dataSlice(hexData, 4)); + return new ErrorDescription(fragment, this.getSelector(fragment), args); + } + + + static from(value: ReadonlyArray | string | Interface) { + // Already an Interface, which is immutable + if (value instanceof Interface) { return value; } + + // JSON + if (typeof(value) === "string") { return new Interface(JSON.parse(value)); } + + // Maybe an interface from an older version, or from a symlinked copy + if (typeof((value).format) === "function") { + return new Interface((value).format(FormatType.json)); + } + + // Array of fragments + return new Interface(value); + } +} diff --git a/src.ts/abi/typed.ts b/src.ts/abi/typed.ts new file mode 100644 index 000000000..a41dd7f5a --- /dev/null +++ b/src.ts/abi/typed.ts @@ -0,0 +1,254 @@ +import { defineProperties } from "../utils/properties.js"; + +import type { Addressable } from "../address/index.js"; +import type { BigNumberish, BytesLike } from "../utils/index.js"; + +import type { Result } from "./coders/abstract-coder.js"; + +const _gaurd = { }; + +function n(value: BigNumberish, width: number): Typed { + let signed = false; + if (width < 0) { + signed = true; + width *= -1; + } + + // @TODO: Check range is valid for value + return new Typed(_gaurd, `${ signed ? "": "u" }int${ width }`, value, { signed, width }); +} + +function b(value: BytesLike, size?: number): Typed { + // @TODO: Check range is valid for value + return new Typed(_gaurd, `bytes${ (size) ? size: "" }`, value, { size }); +} + +export interface TypedNumber extends Typed { + defaultValue(): number; + minValue(): number; + maxValue(): number; +} + +export interface TypedBigInt extends Typed { + defaultValue(): bigint; + minValue(): bigint; + maxValue(): bigint; +} + +export interface TypedData extends Typed { + defaultValue(): string; +} + +export interface TypedString extends Typed { + defaultValue(): string; +} + +const _typedSymbol = Symbol.for("_ethers_typed"); + +export class Typed { + readonly type!: string; + readonly value!: any; + + readonly #options: any; + + readonly _typedSymbol!: Symbol; + + constructor(gaurd: any, type: string, value: any, options: any = null) { + if (gaurd !== _gaurd) { throw new Error("private constructor"); } + defineProperties(this, { _typedSymbol, type, value }); + this.#options = options; + + // Check the value is valid + this.format(); + } + + format(): string { + if (this.type === "array") { + throw new Error(""); + } else if (this.type === "dynamicArray") { + throw new Error(""); + } else if (this.type === "tuple") { + return `tuple(${ this.value.map((v: Typed) => v.format()).join(",") })` + } + + return this.type; + } + + defaultValue(): string | number | bigint | Result { + return 0; + } + + minValue(): string | number | bigint { + return 0; + } + + maxValue(): string | number | bigint { + return 0; + } + + isBigInt(): this is TypedBigInt { + return !!(this.type.match(/^u?int[0-9]+$/)); + } + + isData(): this is TypedData { + return (this.type.substring(0, 5) === "bytes"); + } + + isString(): this is TypedString { + return (this.type === "string"); + } + + get tupleName(): null | string { + if (this.type !== "tuple") { throw TypeError("not a tuple"); } + return this.#options; + } + + // Returns the length of this type as an array + // - `null` indicates the length is unforced, it could be dynamic + // - `-1` indicates the length is dynamic + // - any other value indicates it is a static array and is its length + get arrayLength(): null | number { + if (this.type !== "array") { throw TypeError("not an array"); } + if (this.#options === true) { return -1; } + if (this.#options === false) { return (>(this.value)).length; } + return null; + } + + static from(type: string, value: any): Typed { + return new Typed(_gaurd, type, value); + } + + static uint8(v: BigNumberish): Typed { return n(v, 8); } + static uint16(v: BigNumberish): Typed { return n(v, 16); } + static uint24(v: BigNumberish): Typed { return n(v, 24); } + static uint32(v: BigNumberish): Typed { return n(v, 32); } + static uint40(v: BigNumberish): Typed { return n(v, 40); } + static uint48(v: BigNumberish): Typed { return n(v, 46); } + static uint56(v: BigNumberish): Typed { return n(v, 56); } + static uint64(v: BigNumberish): Typed { return n(v, 64); } + static uint72(v: BigNumberish): Typed { return n(v, 72); } + static uint80(v: BigNumberish): Typed { return n(v, 80); } + static uint88(v: BigNumberish): Typed { return n(v, 88); } + static uint96(v: BigNumberish): Typed { return n(v, 96); } + static uint104(v: BigNumberish): Typed { return n(v, 104); } + static uint112(v: BigNumberish): Typed { return n(v, 112); } + static uint120(v: BigNumberish): Typed { return n(v, 120); } + static uint128(v: BigNumberish): Typed { return n(v, 128); } + static uint136(v: BigNumberish): Typed { return n(v, 136); } + static uint144(v: BigNumberish): Typed { return n(v, 144); } + static uint152(v: BigNumberish): Typed { return n(v, 152); } + static uint160(v: BigNumberish): Typed { return n(v, 160); } + static uint168(v: BigNumberish): Typed { return n(v, 168); } + static uint176(v: BigNumberish): Typed { return n(v, 176); } + static uint184(v: BigNumberish): Typed { return n(v, 184); } + static uint192(v: BigNumberish): Typed { return n(v, 192); } + static uint200(v: BigNumberish): Typed { return n(v, 200); } + static uint208(v: BigNumberish): Typed { return n(v, 208); } + static uint216(v: BigNumberish): Typed { return n(v, 216); } + static uint224(v: BigNumberish): Typed { return n(v, 224); } + static uint232(v: BigNumberish): Typed { return n(v, 232); } + static uint240(v: BigNumberish): Typed { return n(v, 240); } + static uint248(v: BigNumberish): Typed { return n(v, 248); } + static uint256(v: BigNumberish): Typed { return n(v, 256); } + static uint(v: BigNumberish): Typed { return n(v, 256); } + + static int8(v: BigNumberish): Typed { return n(v, -8); } + static int16(v: BigNumberish): Typed { return n(v, -16); } + static int24(v: BigNumberish): Typed { return n(v, -24); } + static int32(v: BigNumberish): Typed { return n(v, -32); } + static int40(v: BigNumberish): Typed { return n(v, -40); } + static int48(v: BigNumberish): Typed { return n(v, -46); } + static int56(v: BigNumberish): Typed { return n(v, -56); } + static int64(v: BigNumberish): Typed { return n(v, -64); } + static int72(v: BigNumberish): Typed { return n(v, -72); } + static int80(v: BigNumberish): Typed { return n(v, -80); } + static int88(v: BigNumberish): Typed { return n(v, -88); } + static int96(v: BigNumberish): Typed { return n(v, -96); } + static int104(v: BigNumberish): Typed { return n(v, -104); } + static int112(v: BigNumberish): Typed { return n(v, -112); } + static int120(v: BigNumberish): Typed { return n(v, -120); } + static int128(v: BigNumberish): Typed { return n(v, -128); } + static int136(v: BigNumberish): Typed { return n(v, -136); } + static int144(v: BigNumberish): Typed { return n(v, -144); } + static int152(v: BigNumberish): Typed { return n(v, -152); } + static int160(v: BigNumberish): Typed { return n(v, -160); } + static int168(v: BigNumberish): Typed { return n(v, -168); } + static int176(v: BigNumberish): Typed { return n(v, -176); } + static int184(v: BigNumberish): Typed { return n(v, -184); } + static int192(v: BigNumberish): Typed { return n(v, -192); } + static int200(v: BigNumberish): Typed { return n(v, -200); } + static int208(v: BigNumberish): Typed { return n(v, -208); } + static int216(v: BigNumberish): Typed { return n(v, -216); } + static int224(v: BigNumberish): Typed { return n(v, -224); } + static int232(v: BigNumberish): Typed { return n(v, -232); } + static int240(v: BigNumberish): Typed { return n(v, -240); } + static int248(v: BigNumberish): Typed { return n(v, -248); } + static int256(v: BigNumberish): Typed { return n(v, -256); } + static int(v: BigNumberish): Typed { return n(v, -256); } + + static bytes(v: BytesLike): Typed { return b(v); } + static bytes1(v: BytesLike): Typed { return b(v, 1); } + static bytes2(v: BytesLike): Typed { return b(v, 2); } + static bytes3(v: BytesLike): Typed { return b(v, 3); } + static bytes4(v: BytesLike): Typed { return b(v, 4); } + static bytes5(v: BytesLike): Typed { return b(v, 5); } + static bytes6(v: BytesLike): Typed { return b(v, 6); } + static bytes7(v: BytesLike): Typed { return b(v, 7); } + static bytes8(v: BytesLike): Typed { return b(v, 8); } + static bytes9(v: BytesLike): Typed { return b(v, 9); } + static bytes10(v: BytesLike): Typed { return b(v, 10); } + static bytes11(v: BytesLike): Typed { return b(v, 11); } + static bytes12(v: BytesLike): Typed { return b(v, 12); } + static bytes13(v: BytesLike): Typed { return b(v, 13); } + static bytes14(v: BytesLike): Typed { return b(v, 14); } + static bytes15(v: BytesLike): Typed { return b(v, 15); } + static bytes16(v: BytesLike): Typed { return b(v, 16); } + static bytes17(v: BytesLike): Typed { return b(v, 17); } + static bytes18(v: BytesLike): Typed { return b(v, 18); } + static bytes19(v: BytesLike): Typed { return b(v, 19); } + static bytes20(v: BytesLike): Typed { return b(v, 20); } + static bytes21(v: BytesLike): Typed { return b(v, 21); } + static bytes22(v: BytesLike): Typed { return b(v, 22); } + static bytes23(v: BytesLike): Typed { return b(v, 23); } + static bytes24(v: BytesLike): Typed { return b(v, 24); } + static bytes25(v: BytesLike): Typed { return b(v, 25); } + static bytes26(v: BytesLike): Typed { return b(v, 26); } + static bytes27(v: BytesLike): Typed { return b(v, 27); } + static bytes28(v: BytesLike): Typed { return b(v, 28); } + static bytes29(v: BytesLike): Typed { return b(v, 29); } + static bytes30(v: BytesLike): Typed { return b(v, 30); } + static bytes31(v: BytesLike): Typed { return b(v, 31); } + static bytes32(v: BytesLike): Typed { return b(v, 32); } + + static address(v: string | Addressable): Typed { return new Typed(_gaurd, "address", v); } + static bool(v: any): Typed { return new Typed(_gaurd, "bool", !!v); } + static string(v: string): Typed { return new Typed(_gaurd, "string", v); } + + static array(v: Array, dynamic?: null | boolean): Typed { + throw new Error("not implemented yet"); + return new Typed(_gaurd, "array", v, dynamic); + } + + static tuple(v: Array | Record, name?: string): Typed { + throw new Error("not implemented yet"); + return new Typed(_gaurd, "tuple", v, name); + } + + static overrides(v: Record): Typed { + return new Typed(_gaurd, "overrides", Object.assign({ }, v)); + } + + static isTyped(value: any): value is Typed { + return (value && value._typedSymbol === _typedSymbol); + } + + static dereference(value: Typed | T, type: string): T { + if (Typed.isTyped(value)) { + if (value.type !== type) { + throw new Error(`invalid type: expecetd ${ type }, got ${ value.type }`); + } + return value.value; + } + return value; + } +} diff --git a/src.ts/address/address.ts b/src.ts/address/address.ts new file mode 100644 index 000000000..e6fc16be0 --- /dev/null +++ b/src.ts/address/address.ts @@ -0,0 +1,125 @@ +import { keccak256 } from "../crypto/keccak.js"; +import { logger } from "../utils/logger.js"; + + +const BN_0 = BigInt(0); +const BN_36 = BigInt(36); + +function getChecksumAddress(address: string): string { +// if (!isHexString(address, 20)) { +// logger.throwArgumentError("invalid address", "address", address); +// } + + address = address.toLowerCase(); + + const chars = address.substring(2).split(""); + + const expanded = new Uint8Array(40); + for (let i = 0; i < 40; i++) { + expanded[i] = chars[i].charCodeAt(0); + } + + const hashed = logger.getBytes(keccak256(expanded)); + + for (let i = 0; i < 40; i += 2) { + if ((hashed[i >> 1] >> 4) >= 8) { + chars[i] = chars[i].toUpperCase(); + } + if ((hashed[i >> 1] & 0x0f) >= 8) { + chars[i + 1] = chars[i + 1].toUpperCase(); + } + } + + return "0x" + chars.join(""); +} + +// See: https://en.wikipedia.org/wiki/International_Bank_Account_Number + +// Create lookup table +const ibanLookup: { [character: string]: string } = { }; +for (let i = 0; i < 10; i++) { ibanLookup[String(i)] = String(i); } +for (let i = 0; i < 26; i++) { ibanLookup[String.fromCharCode(65 + i)] = String(10 + i); } + +// How many decimal digits can we process? (for 64-bit float, this is 15) +// i.e. Math.floor(Math.log10(Number.MAX_SAFE_INTEGER)); +const safeDigits = 15; + +function ibanChecksum(address: string): string { + address = address.toUpperCase(); + address = address.substring(4) + address.substring(0, 2) + "00"; + + let expanded = address.split("").map((c) => { return ibanLookup[c]; }).join(""); + + // Javascript can handle integers safely up to 15 (decimal) digits + while (expanded.length >= safeDigits){ + let block = expanded.substring(0, safeDigits); + expanded = parseInt(block, 10) % 97 + expanded.substring(block.length); + } + + let checksum = String(98 - (parseInt(expanded, 10) % 97)); + while (checksum.length < 2) { checksum = "0" + checksum; } + + return checksum; +}; + +const Base36 = (function() {; + const result: Record = { }; + for (let i = 0; i < 36; i++) { + const key = "0123456789abcdefghijklmnopqrstuvwxyz"[i]; + result[key] = BigInt(i); + } + return result; +})(); + +function fromBase36(value: string): bigint { + value = value.toLowerCase(); + + let result = BN_0; + for (let i = 0; i < value.length; i++) { + result = result * BN_36 + Base36[value[i]]; + } + return result; +} + +export function getAddress(address: string): string { + + if (typeof(address) !== "string") { + logger.throwArgumentError("invalid address", "address", address); + } + + if (address.match(/^(0x)?[0-9a-fA-F]{40}$/)) { + + // Missing the 0x prefix + if (address.substring(0, 2) !== "0x") { address = "0x" + address; } + + const result = getChecksumAddress(address); + + // It is a checksummed address with a bad checksum + if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) && result !== address) { + logger.throwArgumentError("bad address checksum", "address", address); + } + + return result; + } + + // Maybe ICAP? (we only support direct mode) + if (address.match(/^XE[0-9]{2}[0-9A-Za-z]{30,31}$/)) { + // It is an ICAP address with a bad checksum + if (address.substring(2, 4) !== ibanChecksum(address)) { + logger.throwArgumentError("bad icap checksum", "address", address); + } + + let result = fromBase36(address.substring(4)).toString(16); + while (result.length < 40) { result = "0" + result; } + return getChecksumAddress("0x" + result); + } + + return logger.throwArgumentError("invalid address", "address", address); +} + +export function getIcapAddress(address: string): string { + //let base36 = _base16To36(getAddress(address).substring(2)).toUpperCase(); + let base36 = BigInt(getAddress(address)).toString(36).toUpperCase(); + while (base36.length < 30) { base36 = "0" + base36; } + return "XE" + ibanChecksum("XE00" + base36) + base36; +} diff --git a/src.ts/address/checks.ts b/src.ts/address/checks.ts new file mode 100644 index 000000000..f85bec3a2 --- /dev/null +++ b/src.ts/address/checks.ts @@ -0,0 +1,54 @@ +import { logger } from "../utils/logger.js"; + +import { getAddress } from "./address.js"; + +import type { Addressable, AddressLike, NameResolver } from "./index.js"; + + +export function isAddressable(value: any): value is Addressable { + return (value && typeof(value.getAddress) === "function"); +} + +export function isAddress(value: any): boolean { + try { + getAddress(value); + return true; + } catch (error) { } + return false; +} + +async function checkAddress(target: any, promise: Promise): Promise { + const result = await promise; + if (result == null || result === "0x0000000000000000000000000000000000000000") { + if (typeof(target) === "string") { + return logger.throwError("unconfigured name", "UNCONFIGURED_NAME", { value: target }); + } + return logger.throwArgumentError("invalid AddressLike value; did not resolve to a value address", "target", target); + } + return getAddress(result); +} + +// Resolves an Ethereum address, ENS name or Addressable object, +// throwing if the result is null. +export function resolveAddress(target: AddressLike, resolver?: null | NameResolver): string | Promise { + + if (typeof(target) === "string") { + if (target.match(/^0x[0-9a-f]{40}$/i)) { return getAddress(target); } + + if (resolver == null) { + return logger.throwError("ENS resolution requires a provider", "UNSUPPORTED_OPERATION", { + operation: "resolveName", + }); + } + + return checkAddress(target, resolver.resolveName(target)); + + } else if (isAddressable(target)) { + return checkAddress(target, target.getAddress()); + + } else if (typeof(target.then) === "function") { + return checkAddress(target, target); + } + + return logger.throwArgumentError("unsupported addressable value", "target", target); +} diff --git a/src.ts/address/contract-address.ts b/src.ts/address/contract-address.ts new file mode 100644 index 000000000..0bd063da8 --- /dev/null +++ b/src.ts/address/contract-address.ts @@ -0,0 +1,40 @@ +import { keccak256 } from "../crypto/keccak.js"; +import { concat, dataSlice, encodeRlp, logger } from "../utils/index.js"; + +import { getAddress } from "./address.js"; + +import type { BigNumberish, BytesLike } from "../utils/index.js"; + + +// http://ethereum.stackexchange.com/questions/760/how-is-the-address-of-an-ethereum-contract-computed +export function getCreateAddress(tx: { from: string, nonce: BigNumberish }): string { + const from = getAddress(tx.from); + const nonce = logger.getBigInt(tx.nonce, "tx.nonce"); + + let nonceHex = nonce.toString(16); + if (nonceHex === "0") { + nonceHex = "0x"; + } else if (nonceHex.length % 2) { + nonceHex = "0x0" + nonceHex; + } else { + nonceHex = "0x" + nonceHex; + } + + return getAddress(dataSlice(keccak256(encodeRlp([ from, nonceHex ])), 12)); +} + +export function getCreate2Address(_from: string, _salt: BytesLike, _initCodeHash: BytesLike): string { + const from = getAddress(_from); + const salt = logger.getBytes(_salt, "salt"); + const initCodeHash = logger.getBytes(_initCodeHash, "initCodeHash"); + + if (salt.length !== 32) { + logger.throwArgumentError("salt must be 32 bytes", "salt", _salt); + } + + if (initCodeHash.length !== 32) { + logger.throwArgumentError("initCodeHash must be 32 bytes", "initCodeHash", _initCodeHash); + } + + return getAddress(dataSlice(keccak256(concat([ "0xff", from, salt, initCodeHash ])), 12)) +} diff --git a/src.ts/address/index.ts b/src.ts/address/index.ts new file mode 100644 index 000000000..06cbde843 --- /dev/null +++ b/src.ts/address/index.ts @@ -0,0 +1,16 @@ +export interface Addressable { + getAddress(): Promise; +} + +export type AddressLike = string | Promise | Addressable; + +export interface NameResolver { + resolveName(name: string): Promise; +} + +export { getAddress, getIcapAddress } from "./address.js"; + +export { getCreateAddress, getCreate2Address } from "./contract-address.js"; + + +export { isAddressable, isAddress, resolveAddress } from "./checks.js"; diff --git a/src.ts/constants/addresses.ts b/src.ts/constants/addresses.ts new file mode 100644 index 000000000..98baf82ee --- /dev/null +++ b/src.ts/constants/addresses.ts @@ -0,0 +1,6 @@ + +/** + * A constant for the zero address. + */ +export const ZeroAddress = "0x0000000000000000000000000000000000000000"; + diff --git a/src.ts/constants/hashes.ts b/src.ts/constants/hashes.ts new file mode 100644 index 000000000..9cd796191 --- /dev/null +++ b/src.ts/constants/hashes.ts @@ -0,0 +1,5 @@ +/** + * A constant for the zero hash. + */ +export const ZeroHash = "0x0000000000000000000000000000000000000000000000000000000000000000"; + diff --git a/src.ts/constants/index.ts b/src.ts/constants/index.ts new file mode 100644 index 000000000..d7eacf752 --- /dev/null +++ b/src.ts/constants/index.ts @@ -0,0 +1,14 @@ +export { ZeroAddress } from "./addresses.js"; +export { ZeroHash } from "./hashes.js"; +export { + NegativeOne, + Zero, + One, + Two, + N, + WeiPerEther, + MaxUint256, + MinInt256, + MaxInt256 +} from "./numbers.js"; +export { EtherSymbol, MessagePrefix } from "./strings.js"; diff --git a/src.ts/constants/numbers.ts b/src.ts/constants/numbers.ts new file mode 100644 index 000000000..c3a2e3c7b --- /dev/null +++ b/src.ts/constants/numbers.ts @@ -0,0 +1,57 @@ + +/** + * A constant for the BigInt of -1. + */ +const NegativeOne = BigInt(-1); + +/** + * A constant for the BigInt of 0. + */ +const Zero = BigInt(0); + +/** + * A constant for the BigInt of 1. + */ +const One = BigInt(1); + +/** + * A constant for the BigInt of 2. + */ +const Two = BigInt(2); + +/** + * A constant for the order N for the secp256k1 curve. + */ +const N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"); + +/** + * A constant for the number of wei in a single ether. + */ +const WeiPerEther = BigInt("1000000000000000000"); + +/** + * A constant for the maximum value for a ``uint256``. + */ +const MaxUint256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); + +/** + * A constant for the minimum value for an ``int256``. + */ +const MinInt256 = BigInt("0x8000000000000000000000000000000000000000000000000000000000000000") * NegativeOne; + +/** + * A constant for the maximum value for an ``int256``. + */ +const MaxInt256 = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); + +export { + NegativeOne, + Zero, + One, + Two, + N, + WeiPerEther, + MaxUint256, + MinInt256, + MaxInt256, +}; diff --git a/src.ts/constants/strings.ts b/src.ts/constants/strings.ts new file mode 100644 index 000000000..8ec007228 --- /dev/null +++ b/src.ts/constants/strings.ts @@ -0,0 +1,9 @@ +// NFKC (composed) // (decomposed) + +/** + * A constant for the ether symbol (normalized using NFKC). + */ +export const EtherSymbol = "\u039e"; // "\uD835\uDF63"; + + +export const MessagePrefix = "\x19Ethereum Signed Message:\n"; diff --git a/src.ts/contract/contract.ts b/src.ts/contract/contract.ts new file mode 100644 index 000000000..b7dcd2f3e --- /dev/null +++ b/src.ts/contract/contract.ts @@ -0,0 +1,763 @@ +import { resolveAddress } from "../address/index.js"; +import { Interface, Typed } from "../abi/index.js"; +import { + defineProperties, isCallException, isHexString, resolveProperties, logger +} from "../utils/index.js"; +import { copyRequest, Log, TransactionResponse } from "../providers/index.js"; + +import { + ContractEventPayload, + ContractTransactionResponse, + EventLog +} from "./wrappers.js"; + +import type { EventFragment, FunctionFragment, InterfaceAbi, ParamType, Result } from "../abi/index.js"; +import type { Addressable } from "../address/index.js"; +import type { EventEmitterable, Listener } from "../utils/index.js"; +import type { + BlockTag, ContractRunner, Provider, TransactionRequest, TopicFilter +} from "../providers/index.js"; + +import type { + ContractEventName, + ContractInterface, + ContractMethodArgs, + BaseContractMethod, + ContractMethod, + ContractEventArgs, + ContractEvent, + ContractTransaction, + DeferredTopicFilter +} from "./types.js"; + +interface ContractRunnerCaller extends ContractRunner { + call: (tx: TransactionRequest) => Promise; +} + +interface ContractRunnerEstimater extends ContractRunner { + estimateGas: (tx: TransactionRequest) => Promise; +} + +interface ContractRunnerSender extends ContractRunner { + sendTransaction: (tx: TransactionRequest) => Promise; +} + +interface ContractRunnerResolver extends ContractRunner { + resolveName: (name: string | Addressable) => Promise; +} + +function canCall(value: any): value is ContractRunnerCaller { + return (value && typeof(value.call) === "function"); +} + +function canEstimate(value: any): value is ContractRunnerEstimater { + return (value && typeof(value.estimateGas) === "function"); +} + +function canResolve(value: any): value is ContractRunnerResolver { + return (value && typeof(value.resolveName) === "function"); +} + +function canSend(value: any): value is ContractRunnerSender { + return (value && typeof(value.sendTransaction) === "function"); +} + +function concisify(items: Array): Array { + items = Array.from((new Set(items)).values()) + items.sort(); + return items; +} + +class PreparedTopicFilter implements DeferredTopicFilter { + #filter: Promise; + readonly fragment!: EventFragment; + + constructor(contract: BaseContract, fragment: EventFragment, args: Array) { + defineProperties(this, { fragment }); + if (fragment.inputs.length < args.length) { + throw new Error("too many arguments"); + } + + // Recursively descend into args and resolve any addresses + const runner = getRunner(contract.runner, "resolveName"); + const resolver = canResolve(runner) ? runner: null; + this.#filter = (async function() { + const resolvedArgs = await Promise.all(fragment.inputs.map((param, index) => { + return param.walkAsync(args[index], (type, value) => { + if (type === "address") { return resolveAddress(value, resolver); } + return value; + }); + })); + + return contract.interface.encodeFilterTopics(fragment, resolvedArgs); + })(); + } + + getTopicFilter(): Promise { + return this.#filter; + } +} + + +// A = Arguments passed in as a tuple +// R = The result type of the call (i.e. if only one return type, +// the qualified type, otherwise Result) +// D = The type the default call will return (i.e. R for view/pure, +// TransactionResponse otherwise) +//export interface ContractMethod = Array, R = any, D extends R | ContractTransactionResponse = ContractTransactionResponse> { + +function _WrappedMethodBase(): new () => Function & BaseContractMethod { + return Function as any; +} + +function getRunner(value: any, feature: keyof ContractRunner): null | T { + if (value == null) { return null; } + if (typeof(value[feature]) === "function") { return value; } + if (value.provider && typeof(value.provider[feature]) === "function") { + return value.provider; + } + return null; +} + +function getProvider(value: null | ContractRunner): null | Provider { + if (value == null) { return null; } + return value.provider || null; +} + +export async function copyOverrides(arg: any): Promise> { + + // Create a shallow copy (we'll deep-ify anything needed during normalizing) + const overrides = copyRequest(Typed.dereference(arg, "overrides")); + + // Some sanity checking; these are what these methods adds + //if ((overrides).to) { + if (overrides.to) { + logger.throwArgumentError("cannot override to", "overrides.to", overrides.to); + } else if (overrides.data) { + logger.throwArgumentError("cannot override data", "overrides.data", overrides.data); + } + + // Resolve any from + if (overrides.from) { + overrides.from = await resolveAddress(overrides.from); + } + + return overrides; +} + +export async function resolveArgs(_runner: null | ContractRunner, inputs: ReadonlyArray, args: Array): Promise> { + // Recursively descend into args and resolve any addresses + const runner = getRunner(_runner, "resolveName"); + const resolver = canResolve(runner) ? runner: null; + return await Promise.all(inputs.map((param, index) => { + return param.walkAsync(args[index], (type, value) => { + if (type === "address") { return resolveAddress(value, resolver); } + return value; + }); + })); +} + +class WrappedMethod = Array, R = any, D extends R | ContractTransactionResponse = ContractTransactionResponse> + extends _WrappedMethodBase() implements BaseContractMethod { + + readonly name: string = ""; // Investigate! + readonly _contract!: BaseContract; + readonly _key!: string; + + constructor (contract: BaseContract, key: string) { + super(); + + defineProperties(this, { + name: contract.interface.getFunctionName(key), + _contract: contract, _key: key + }); + + const proxy = new Proxy(this, { + // Perform the default operation for this fragment type + apply: async (target, thisArg, args: ContractMethodArgs) => { + const fragment = target.getFragment(...args); + if (fragment.constant) { return await target.staticCall(...args); } + return await target.send(...args); + }, + }); + + return proxy; + } + + // Only works on non-ambiguous keys (refined fragment is always non-ambiguous) + get fragment(): FunctionFragment { + return this._contract.interface.getFunction(this._key); + } + + getFragment(...args: ContractMethodArgs): FunctionFragment { + return this._contract.interface.getFunction(this._key, args); + } + + async populateTransaction(...args: ContractMethodArgs): Promise { + const fragment = this.getFragment(...args); + + // If an overrides was passed in, copy it and normalize the values + let overrides: Omit = { }; + if (fragment.inputs.length + 1 === args.length) { + overrides = await copyOverrides(args.pop()); + } + + if (fragment.inputs.length !== args.length) { + throw new Error("internal error: fragment inputs doesn't match arguments; should not happen"); + } + + const resolvedArgs = await resolveArgs(this._contract.runner, fragment.inputs, args); + + return Object.assign({ }, overrides, await resolveProperties({ + to: this._contract.getAddress(), + data: this._contract.interface.encodeFunctionData(fragment, resolvedArgs) + })); + } + + async staticCall(...args: ContractMethodArgs): Promise { + const result = await this.staticCallResult(...args); + if (result.length === 1) { return result[0]; } + return result; + } + + async send(...args: ContractMethodArgs): Promise { + const runner = this._contract.runner; + if (!canSend(runner)) { + return logger.throwError("contract runner does not support sending transactions", "UNSUPPORTED_OPERATION", { + operation: "sendTransaction" + }); + } + const tx = await runner.sendTransaction(await this.populateTransaction(...args)); + const provider = getProvider(this._contract.runner); + return new ContractTransactionResponse(this._contract.interface, provider, tx); + } + + async estimateGas(...args: ContractMethodArgs): Promise { + const runner = getRunner(this._contract.runner, "estimateGas"); + if (!canEstimate(runner)) { + return logger.throwError("contract runner does not support gas estimation", "UNSUPPORTED_OPERATION", { + operation: "estimateGas" + }); + } + return await runner.estimateGas(await this.populateTransaction(...args)); + } + + async staticCallResult(...args: ContractMethodArgs): Promise { + const runner = getRunner(this._contract.runner, "call"); + if (!canCall(runner)) { + return logger.throwError("contract runner does not support calling", "UNSUPPORTED_OPERATION", { + operation: "call" + }); + } + + const fragment = this.getFragment(...args); + const tx = await this.populateTransaction(...args); + + let result = "0x"; + try { + result = await runner.call(tx); + } catch (error: any) { + if (isCallException(error)) { + throw this._contract.interface.makeError(fragment, error.data, tx); + } + throw error; + } + + return this._contract.interface.decodeFunctionResult(fragment, result); + } +} + +function _WrappedEventBase(): new () => Function & ContractEvent { + return Function as any; +} + +class WrappedEvent = Array> extends _WrappedEventBase() implements ContractEvent { + readonly name: string = ""; // @TODO: investigate + + readonly _contract!: BaseContract; + readonly _key!: string; + + constructor (contract: BaseContract, key: string) { + super(); + + defineProperties(this, { + name: contract.interface.getEventName(key), + _contract: contract, _key: key + }); + + return new Proxy(this, { + // Perform the default operation for this fragment type + apply: async (target, thisArg, args: ContractEventArgs) => { + return new PreparedTopicFilter(contract, target.getFragment(...args), args); + }, + }); + } + + // Only works on non-ambiguous keys + get fragment(): EventFragment { + return this._contract.interface.getEvent(this._key); + } + + getFragment(...args: ContractEventArgs): EventFragment { + return this._contract.interface.getEvent(this._key, args); + } +}; + +type Sub = { + tag: string; + listeners: Array<{ listener: Listener, once: boolean }>, + start: () => void; + stop: () => void; +}; + + +// The combination of TypeScrype, Private Fields and Proxies makes +// the world go boom; so we hide variables with some trickery keeping +// a symbol attached to each BaseContract which its sub-class (even +// via a Proxy) can reach and use to look up its internal values. + +const internal = Symbol.for("_ethersInternal_contract"); +type Internal = { + addrPromise: Promise; + addr: null | string; + + deployTx: null | ContractTransactionResponse; + + subs: Map; +}; + +const internalValues: WeakMap = new WeakMap(); + +function setInternal(contract: BaseContract, values: Internal): void { + internalValues.set(contract[internal], values); +} + +function getInternal(contract: BaseContract): Internal { + return internalValues.get(contract[internal]) as Internal; +} + +function isDeferred(value: any): value is DeferredTopicFilter { + return (value && typeof(value) === "object" && ("getTopicFilter" in value) && + (typeof(value.getTopicFilter) === "function") && value.fragment); +} + +async function getSubTag(contract: BaseContract, event: ContractEventName): Promise<{ tag: string, fragment: EventFragment, topics: TopicFilter }> { + let fragment: EventFragment; + let topics: Array>; + + if (Array.isArray(event)) { + // Topics; e.g. `[ "0x1234...89ab" ]` + fragment = contract.interface.getEvent(event[0] as string); + topics = event; + + } else if (typeof(event) === "string") { + // Event name (name or signature); `"Transfer"` + fragment = contract.interface.getEvent(event); + topics = [ contract.interface.getEventTopic(fragment) ]; + + } else if (isDeferred(event)) { + // Deferred Topic Filter; e.g. `contract.filter.Transfer(from)` + fragment = event.fragment; + topics = await event.getTopicFilter(); + + } else if ("fragment" in event) { + // ContractEvent; e.g. `contract.filter.Transfer` + fragment = event.fragment; + topics = [ contract.interface.getEventTopic(fragment) ]; + + } else { + console.log(event); + throw new Error("TODO"); + } + + // Normalize topics and sort TopicSets + topics = topics.map((t) => { + if (t == null) { return null; } + if (Array.isArray(t)) { + return concisify(t.map((t) => t.toLowerCase())); + } + return t.toLowerCase(); + }); + + const tag = topics.map((t) => { + if (t == null) { return "null"; } + if (Array.isArray(t)) { return t.join("|"); } + return t; + }).join("&"); + + return { fragment, tag, topics } +} + +async function hasSub(contract: BaseContract, event: ContractEventName): Promise { + const { subs } = getInternal(contract); + return subs.get((await getSubTag(contract, event)).tag) || null; +} + +async function getSub(contract: BaseContract, event: ContractEventName): Promise { + // Make sure our runner can actually subscribe to events + const provider = getProvider(contract.runner); + if (!provider) { + return logger.throwError("contract runner does not support subscribing", "UNSUPPORTED_OPERATION", { + operation: "on" + }); + } + + const { fragment, tag, topics } = await getSubTag(contract, event); + + const { addr, subs } = getInternal(contract); + + let sub = subs.get(tag); + if (!sub) { + const address: string | Addressable = (addr ? addr: contract); + const filter = { address, topics }; + const listener = (log: Log) => { + const payload = new ContractEventPayload(contract, null, event, fragment, log); + emit(contract, event, payload.args, payload); + }; + + let started = false; + const start = () => { + if (started) { return; } + provider.on(filter, listener); + started = true; + }; + const stop = () => { + if (!started) { return; } + provider.off(filter, listener); + started = false; + }; + sub = { tag, listeners: [ ], start, stop }; + subs.set(tag, sub); + } + return sub; +} + +// We use this to ensure one emit resolves before firing the next to +// ensure correct ordering (note this cannot throw and just adds the +// notice to the event queu using setTimeout). +let lastEmit: Promise = Promise.resolve(); + +async function _emit(contract: BaseContract, event: ContractEventName, args: Array, payload: null | ContractEventPayload): Promise { + await lastEmit; + + const sub = await hasSub(contract, event); + if (!sub) { return false; } + + const count = sub.listeners.length; + sub.listeners = sub.listeners.filter(({ listener, once }) => { + const passArgs = args.slice(); + if (payload) { + passArgs.push(new ContractEventPayload(contract, (once ? null: listener), + event, payload.fragment, payload.log)); + } + try { + listener.call(contract, ...passArgs); + } catch (error) { } + return !once; + }); + return (count > 0); +} + +async function emit(contract: BaseContract, event: ContractEventName, args: Array, payload: null | ContractEventPayload): Promise { + try { + await lastEmit; + } catch (error) { } + + const resultPromise = _emit(contract, event, args, payload); + lastEmit = resultPromise; + return await resultPromise; +} + +const passProperties = [ "then" ]; +export class BaseContract implements Addressable, EventEmitterable { + readonly target!: string | Addressable; + readonly interface!: Interface; + readonly runner!: null | ContractRunner; + + readonly filters!: Record; + + readonly [internal]: any; + + constructor(target: string | Addressable, abi: Interface | InterfaceAbi, runner: null | ContractRunner = null, _deployTx?: null | TransactionResponse) { + const iface = Interface.from(abi); + defineProperties(this, { target, runner, interface: iface }); + + Object.defineProperty(this, internal, { value: { } }); + + let addrPromise; + let addr = null; + + let deployTx: null | ContractTransactionResponse = null; + if (_deployTx) { + const provider = getProvider(runner); + deployTx = new ContractTransactionResponse(this.interface, provider, _deployTx); + } + + let subs = new Map(); + + // Resolve the target as the address + if (typeof(target) === "string") { + if (isHexString(target)) { + addr = target; + addrPromise = Promise.resolve(target); + + } else { + const resolver = getRunner(runner, "resolveName"); + if (!canResolve(resolver)) { + throw logger.makeError("contract runner does not support name resolution", "UNSUPPORTED_OPERATION", { + operation: "resolveName" + }); + } + + addrPromise = resolver.resolveName(target).then((addr) => { + if (addr == null) { throw new Error("TODO"); } + getInternal(this).addr = addr; + return addr; + }); + } + } else { + addrPromise = target.getAddress().then((addr) => { + if (addr == null) { throw new Error("TODO"); } + getInternal(this).addr = addr; + return addr; + }); + } + + // Set our private values + setInternal(this, { addrPromise, addr, deployTx, subs }); + + // Add the event filters + const filters = new Proxy({ }, { + get: (target, _prop, receiver) => { + // Pass important checks (like `then` for Promise) through + if (passProperties.indexOf(_prop) >= 0) { + return Reflect.get(target, _prop, receiver); + } + + const prop = String(_prop); + + const result = this.getEvent(prop); + if (result) { return result; } + + throw new Error(`unknown contract event: ${ prop }`); + } + }); + defineProperties(this, { filters }); + + // Return a Proxy that will respond to functions + return new Proxy(this, { + get: (target, _prop, receiver) => { + if (_prop in target || passProperties.indexOf(_prop) >= 0) { + return Reflect.get(target, _prop, receiver); + } + + const prop = String(_prop); + + const result = target.getFunction(prop); + if (result) { return result; } + + throw new Error(`unknown contract method: ${ prop }`); + } + }); + } + + async getAddress(): Promise { return await getInternal(this).addrPromise; } + + async getDeployedCode(): Promise { + const provider = getProvider(this.runner); + if (!provider) { + return logger.throwError("runner does not support .provider", "UNSUPPORTED_OPERATION", { + operation: "getDeployedCode" + }); + } + + const code = await provider.getCode(await this.getAddress()); + if (code === "0x") { return null; } + return code; + } + + async waitForDeployment(): Promise { + // We have the deployement transaction; just use that (throws if deployement fails) + const deployTx = this.deploymentTransaction(); + if (deployTx) { + await deployTx.wait(); + return this; + } + + // Check for code + const code = await this.getDeployedCode(); + if (code != null) { return this; } + + // Make sure we can subscribe to a provider event + const provider = getProvider(this.runner); + if (provider == null) { + return logger.throwError("contract runner does not support .provider", "UNSUPPORTED_OPERATION", { + operation: "waitForDeployment" + }); + } + + return new Promise((resolve, reject) => { + const checkCode = async () => { + try { + const code = await this.getDeployedCode(); + if (code != null) { return resolve(this); } + provider.once("block", checkCode); + } catch (error) { + reject(error); + } + }; + checkCode(); + }); + } + + deploymentTransaction(): null | ContractTransactionResponse { + return getInternal(this).deployTx; + } + + getFunction(key: string | FunctionFragment): T { + if (typeof(key) !== "string") { key = key.format(); } + return (new WrappedMethod(this, key)); + } + + getEvent(key: string | EventFragment): ContractEvent { + if (typeof(key) !== "string") { key = key.format(); } + return (new WrappedEvent(this, key)); + } + + async queryTransaction(hash: string): Promise> { + // Is this useful? + throw new Error("@TODO"); + } + + async queryFilter(event: ContractEventName, fromBlock: BlockTag = 0, toBlock: BlockTag = "latest"): Promise> { + const { addr, addrPromise } = getInternal(this); + const address = (addr ? addr: (await addrPromise)); + const { fragment, topics } = await getSubTag(this, event); + const filter = { address, topics, fromBlock, toBlock }; + + const provider = getProvider(this.runner); + if (!provider) { + return logger.throwError("contract runner does not have a provider", "UNSUPPORTED_OPERATION", { + operation: "queryFilter" + }); + } + + return (await provider.getLogs(filter)).map((log) => { + return new EventLog(log, this.interface, fragment); + }); + } + + async on(event: ContractEventName, listener: Listener): Promise { + const sub = await getSub(this, event); + sub.listeners.push({ listener, once: false }); + sub.start(); + return this; + } + + async once(event: ContractEventName, listener: Listener): Promise { + const sub = await getSub(this, event); + sub.listeners.push({ listener, once: true }); + sub.start(); + return this; + } + + async emit(event: ContractEventName, ...args: Array): Promise { + return await emit(this, event, args, null); + } + + async listenerCount(event?: ContractEventName): Promise { + if (event) { + const sub = await hasSub(this, event); + if (!sub) { return 0; } + return sub.listeners.length; + } + + const { subs } = getInternal(this); + + let total = 0; + for (const { listeners } of subs.values()) { + total += listeners.length; + } + return total; + } + + async listeners(event?: ContractEventName): Promise> { + if (event) { + const sub = await hasSub(this, event); + if (!sub) { return [ ]; } + return sub.listeners.map(({ listener }) => listener); + } + + const { subs } = getInternal(this); + + let result: Array = [ ]; + for (const { listeners } of subs.values()) { + result = result.concat(listeners.map(({ listener }) => listener)); + } + return result; + } + + async off(event: ContractEventName, listener?: Listener): Promise { + const sub = await hasSub(this, event); + if (!sub) { return this; } + + if (listener) { + const index = sub.listeners.map(({ listener }) => listener).indexOf(listener); + if (index >= 0) { sub.listeners.splice(index, 1); } + } + + if (listener == null || sub.listeners.length === 0) { + sub.stop(); + getInternal(this).subs.delete(sub.tag); + } + + return this; + } + + async removeAllListeners(event?: ContractEventName): Promise { + if (event) { + const sub = await hasSub(this, event); + if (!sub) { return this; } + sub.stop(); + getInternal(this).subs.delete(sub.tag); + } else { + const { subs } = getInternal(this); + for (const { tag, stop } of subs.values()) { + stop(); + subs.delete(tag); + } + } + + return this; + } + + // Alias for "on" + async addListener(event: ContractEventName, listener: Listener): Promise { + return await this.on(event, listener); + } + + // Alias for "off" + async removeListener(event: ContractEventName, listener: Listener): Promise { + return await this.off(event, listener); + } + + static buildClass(abi: InterfaceAbi): new (target: string, runner?: null | ContractRunner) => BaseContract & Omit { + class CustomContract extends BaseContract { + constructor(address: string, runner: null | ContractRunner = null) { + super(address, abi, runner); + } + } + return CustomContract as any; + }; + + static from(target: string, abi: InterfaceAbi, runner: null | ContractRunner = null): BaseContract & Omit { + const contract = new this(target, abi, runner); + return contract as any; + } +} + +function _ContractBase(): new (target: string, abi: InterfaceAbi, runner?: null | ContractRunner) => BaseContract & Omit { + return BaseContract as any; +} + +export class Contract extends _ContractBase() { } diff --git a/src.ts/contract/factory.ts b/src.ts/contract/factory.ts new file mode 100644 index 000000000..3e766ec08 --- /dev/null +++ b/src.ts/contract/factory.ts @@ -0,0 +1,97 @@ + +import { Interface } from "../abi/index.js"; +import { getCreateAddress } from "../address/index.js"; +import { concat, defineProperties, hexlify, logger } from "../utils/index.js"; + +import { BaseContract, copyOverrides, resolveArgs } from "./contract.js"; + +import type { InterfaceAbi } from "../abi/index.js"; +import type { ContractRunner } from "../providers/index.js"; +import type { BytesLike } from "../utils/index.js"; + +import type { + ContractInterface, ContractMethodArgs, ContractDeployTransaction, +} from "./types.js"; +import type { ContractTransactionResponse } from "./wrappers.js"; + + +// A = Arguments to the constructor +// I = Interface of deployed contracts +export class ContractFactory = Array, I = BaseContract> { + readonly interface!: Interface; + readonly bytecode!: string; + readonly runner!: null | ContractRunner; + + constructor(abi: Interface | InterfaceAbi, bytecode: BytesLike | { object: string }, runner?: null | ContractRunner) { + const iface = Interface.from(abi); + + // Dereference Solidity bytecode objects and allow a missing `0x`-prefix + if (bytecode instanceof Uint8Array) { + bytecode = hexlify(logger.getBytes(bytecode)); + } else { + if (typeof(bytecode) === "object") { bytecode = bytecode.object; } + if (bytecode.substring(0, 2) !== "0x") { bytecode = "0x" + bytecode; } + bytecode = hexlify(logger.getBytes(bytecode)); + } + + defineProperties(this, { + bytecode, interface: iface, runner: (runner || null) + }); + } + + async getDeployTransaction(...args: ContractMethodArgs): Promise { + let overrides: Omit = { }; + + const fragment = this.interface.deploy; + + if (fragment.inputs.length + 1 === args.length) { + overrides = await copyOverrides(args.pop()); + } + + if (fragment.inputs.length !== args.length) { + throw new Error("incorrect number of arguments to constructor"); + } + + const resolvedArgs = await resolveArgs(this.runner, fragment.inputs, args); + + const data = concat([ this.bytecode, this.interface.encodeDeploy(resolvedArgs) ]); + return Object.assign({ }, overrides, { data }); + } + + async deploy(...args: ContractMethodArgs): Promise> { + const tx = await this.getDeployTransaction(...args); + + if (!this.runner || typeof(this.runner.sendTransaction) !== "function") { + return logger.throwError("factory runner does not support sending transactions", "UNSUPPORTED_OPERATION", { + operation: "sendTransaction" + }); + } + + const sentTx = await this.runner.sendTransaction(tx); + const address = getCreateAddress(sentTx); + return new (BaseContract)(address, this.interface, this.runner, sentTx); + } + + connect(runner: null | ContractRunner): ContractFactory { + return new ContractFactory(this.interface, this.bytecode, runner); + } + + static fromSolidity = Array, I = ContractInterface>(output: any, runner?: ContractRunner): ContractFactory { + if (output == null) { + logger.throwArgumentError("bad compiler output", "output", output); + } + + if (typeof(output) === "string") { output = JSON.parse(output); } + + const abi = output.abi; + + let bytecode = ""; + if (output.bytecode) { + bytecode = output.bytecode; + } else if (output.evm && output.evm.bytecode) { + bytecode = output.evm.bytecode; + } + + return new this(abi, bytecode, runner); + } +} diff --git a/src.ts/contract/index.ts b/src.ts/contract/index.ts new file mode 100644 index 000000000..4d33d011a --- /dev/null +++ b/src.ts/contract/index.ts @@ -0,0 +1,19 @@ + +export { + BaseContract, Contract +} from "./contract.js"; + +export { + ContractFactory +} from "./factory.js"; + +export { + ContractEventPayload, ContractTransactionReceipt, ContractTransactionResponse, + EventLog +} from "./wrappers.js"; + +export type { + ConstantContractMethod, ContractEvent, ContractEventArgs, ContractEventName, + ContractInterface, ContractMethod, ContractMethodArgs, ContractTransaction, + DeferredTopicFilter, Overrides +} from "./types.js"; diff --git a/src.ts/contract/types.ts b/src.ts/contract/types.ts new file mode 100644 index 000000000..e514cdf83 --- /dev/null +++ b/src.ts/contract/types.ts @@ -0,0 +1,83 @@ +import type { + EventFragment, FunctionFragment, Result, Typed +} from "../abi/index.js"; +import type { + CallRequest, PreparedRequest, TopicFilter +} from "../providers/index.js"; + +import type { ContractTransactionResponse } from "./wrappers.js"; + + +// The types of events a Contract can listen for +export type ContractEventName = string | ContractEvent | TopicFilter; + +export interface ContractInterface { + [ name: string ]: BaseContractMethod; +}; + +export interface DeferredTopicFilter { + getTopicFilter(): Promise; + fragment: EventFragment; +} + +export interface ContractTransaction extends PreparedRequest { + // These are populated by contract methods and cannot bu null + to: string; + data: string; +} + +// Deployment Transactions have no `to` +export interface ContractDeployTransaction extends Omit { } + +// Overrides; cannot override `to` or `data` as Contract populates these +export interface Overrides extends Omit { }; + + +// Arguments for methods; with an optional (n+1)th Override +export type PostfixOverrides> = A | [ ...A, Overrides ]; +export type ContractMethodArgs> = PostfixOverrides<{ [ I in keyof A ]-?: A[I] | Typed }>; + +// A = Arguments passed in as a tuple +// R = The result type of the call (i.e. if only one return type, +// the qualified type, otherwise Result) +// D = The type the default call will return (i.e. R for view/pure, +// TransactionResponse otherwise) +export interface BaseContractMethod = Array, R = any, D extends R | ContractTransactionResponse = R | ContractTransactionResponse> { + (...args: ContractMethodArgs): Promise; + + name: string; + + fragment: FunctionFragment; + + getFragment(...args: ContractMethodArgs): FunctionFragment; + + populateTransaction(...args: ContractMethodArgs): Promise; + staticCall(...args: ContractMethodArgs): Promise; + send(...args: ContractMethodArgs): Promise; + estimateGas(...args: ContractMethodArgs): Promise; + staticCallResult(...args: ContractMethodArgs): Promise; +} + +export interface ContractMethod< + A extends Array = Array, + R = any, + D extends R | ContractTransactionResponse = R | ContractTransactionResponse +> extends BaseContractMethod { } + +export interface ConstantContractMethod< + A extends Array, + R = any +> extends ContractMethod { } + + +// Arguments for events; with each element optional and/or nullable +export type ContractEventArgs> = { [ I in keyof A ]?: A[I] | Typed | null }; + +export interface ContractEvent = Array> { + (...args: ContractEventArgs): DeferredTopicFilter; + + name: string; + + fragment: EventFragment; + getFragment(...args: ContractEventArgs): EventFragment; +}; diff --git a/src.ts/contract/wrappers.ts b/src.ts/contract/wrappers.ts new file mode 100644 index 000000000..a9b46c3ee --- /dev/null +++ b/src.ts/contract/wrappers.ts @@ -0,0 +1,99 @@ +import { + Block, Log, TransactionReceipt, TransactionResponse +} from "../providers/index.js"; +import { defineProperties, EventPayload } from "../utils/index.js"; + +import type { EventFragment, Interface, Result } from "../abi/index.js"; +import type { Listener } from "../utils/index.js"; +import type { + Provider +} from "../providers/index.js"; + +import type { BaseContract } from "./contract.js"; +import type { ContractEventName } from "./types.js"; + + +export class EventLog extends Log { + readonly interface!: Interface; + readonly fragment!: EventFragment; + readonly args!: Result; + + constructor(log: Log, iface: Interface, fragment: EventFragment) { + super(log, log.provider); + const args = iface.decodeEventLog(fragment, log.data, log.topics); + defineProperties(this, { args, fragment, interface: iface }); + } + + get eventName(): string { return this.fragment.name; } + get eventSignature(): string { return this.fragment.format(); } +} + +export class ContractTransactionReceipt extends TransactionReceipt { + readonly #interface: Interface; + + constructor(iface: Interface, provider: null | Provider, tx: TransactionReceipt) { + super(tx, provider); + this.#interface = iface; + } + + get logs(): Array { + return super.logs.map((log) => { + const fragment = log.topics.length ? this.#interface.getEvent(log.topics[0]): null; + if (fragment) { + return new EventLog(log, this.#interface, fragment) + } else { + return log; + } + }); + } + +} + +export class ContractTransactionResponse extends TransactionResponse { + readonly #interface: Interface; + + constructor(iface: Interface, provider: null | Provider, tx: TransactionResponse) { + super(tx, provider); + this.#interface = iface; + } + + async wait(confirms?: number): Promise { + const receipt = await super.wait(); + if (receipt == null) { return null; } + return new ContractTransactionReceipt(this.#interface, this.provider, receipt); + } +} + +export class ContractEventPayload extends EventPayload { + + readonly fragment!: EventFragment; + readonly log!: EventLog; + readonly args!: Result; + + constructor(contract: BaseContract, listener: null | Listener, filter: ContractEventName, fragment: EventFragment, _log: Log) { + super(contract, listener, filter); + const log = new EventLog(_log, contract.interface, fragment); + const args = contract.interface.decodeEventLog(fragment, log.data, log.topics); + defineProperties(this, { args, fragment, log }); + } + + get eventName(): string { + return this.fragment.name; + } + + get eventSignature(): string { + return this.fragment.format(); + } + + async getBlock(): Promise> { + return await this.log.getBlock(); + } + + async getTransaction(): Promise { + return await this.log.getTransaction(); + } + + async getTransactionReceipt(): Promise { + return await this.log.getTransactionReceipt(); + } +} diff --git a/src.ts/crypto/crypto-browser.ts b/src.ts/crypto/crypto-browser.ts new file mode 100644 index 000000000..cc0d074b9 --- /dev/null +++ b/src.ts/crypto/crypto-browser.ts @@ -0,0 +1,73 @@ +/* Browser Crypto Shims */ + +import { hmac } from "@noble/hashes/hmac"; +import { pbkdf2 } from "@noble/hashes/pbkdf2"; +import { sha256 } from "@noble/hashes/sha256"; +import { sha512 } from "@noble/hashes/sha512"; + +import { logger } from "../utils/logger.js"; + + +declare global { + interface Window { } + + const window: Window; + const self: Window; +} + + +function getGlobal(): any { + if (typeof self !== 'undefined') { return self; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + throw new Error('unable to locate global object'); +}; + +const anyGlobal = getGlobal(); +const crypto: any = anyGlobal.crypto || anyGlobal.msCrypto; + + +export interface CryptoHasher { + update(data: Uint8Array): CryptoHasher; + digest(): Uint8Array; +} + +export function createHash(algo: string): CryptoHasher { + switch (algo) { + case "sha256": return sha256.create(); + case "sha512": return sha512.create(); + } + return logger.throwArgumentError("invalid hashing algorithm name", "algorithm", algo); +} + +export function createHmac(_algo: string, key: Uint8Array): CryptoHasher { + const algo = ({ sha256, sha512 }[_algo]); + if (algo == null) { + return logger.throwArgumentError("invalid hmac algorithm", "algorithm", _algo); + } + return hmac.create(algo, key); +} + +export function pbkdf2Sync(password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, _algo: "sha256" | "sha512"): Uint8Array { + const algo = ({ sha256, sha512 }[_algo]); + if (algo == null) { + return logger.throwArgumentError("invalid pbkdf2 algorithm", "algorithm", _algo); + } + return pbkdf2(algo, password, salt, { c: iterations, dkLen: keylen }); +} + +export function randomBytes(length: number): Uint8Array { + if (crypto == null) { + return logger.throwError("platform does not support secure random numbers", "UNSUPPORTED_OPERATION", { + operation: "randomBytes" + }); + } + + if (!Number.isInteger(length) || length <= 0 || length > 1024) { + logger.throwArgumentError("invalid length", "length", length); + } + + const result = new Uint8Array(length); + crypto.getRandomValues(result); + return result; +} diff --git a/src.ts/crypto/crypto.ts b/src.ts/crypto/crypto.ts new file mode 100644 index 000000000..142ee3f00 --- /dev/null +++ b/src.ts/crypto/crypto.ts @@ -0,0 +1,4 @@ + +export { + createHash, createHmac, pbkdf2Sync, randomBytes +} from "crypto"; diff --git a/src.ts/crypto/hmac.ts b/src.ts/crypto/hmac.ts new file mode 100644 index 000000000..f37b291aa --- /dev/null +++ b/src.ts/crypto/hmac.ts @@ -0,0 +1,26 @@ +import { createHmac } from "./crypto.js"; +import { hexlify, logger } from "../utils/index.js"; + +import type { BytesLike } from "../utils/index.js"; + + +let locked = false; + +const _computeHmac = function(algorithm: "sha256" | "sha512", key: Uint8Array, data: Uint8Array): BytesLike { + return "0x" + createHmac(algorithm, key).update(data).digest("hex"); +} + +let __computeHmac = _computeHmac; + +export function computeHmac(algorithm: "sha256" | "sha512", _key: BytesLike, _data: BytesLike): string { + const key = logger.getBytes(_key, "key"); + const data = logger.getBytes(_data, "data"); + return hexlify(__computeHmac(algorithm, key, data)); +} +computeHmac._ = _computeHmac; +computeHmac.lock = function() { locked = true; } +computeHmac.register = function(func: (algorithm: "sha256" | "sha512", key: Uint8Array, data: Uint8Array) => BytesLike) { + if (locked) { throw new Error("computeHmac is locked"); } + __computeHmac = func; +} +Object.freeze(computeHmac); diff --git a/src.ts/crypto/index.ts b/src.ts/crypto/index.ts new file mode 100644 index 000000000..2ce7efbf2 --- /dev/null +++ b/src.ts/crypto/index.ts @@ -0,0 +1,45 @@ +// We import all these so we can export lock() +import { computeHmac } from "./hmac.js"; +import { keccak256 } from "./keccak.js"; +import { ripemd160 } from "./ripemd160.js"; +import { pbkdf2 } from "./pbkdf2.js"; +import { randomBytes } from "./random.js"; +import { scrypt, scryptSync } from "./scrypt.js"; +import { sha256, sha512 } from "./sha2.js"; + +export { + computeHmac, + + randomBytes, + + keccak256, + ripemd160, + sha256, sha512, + + pbkdf2, + scrypt, scryptSync +}; + +export { SigningKey } from "./signing-key.js"; +export { Signature } from "./signature.js"; + +function lock(): void { + computeHmac.lock(); + keccak256.lock(); + pbkdf2.lock(); + randomBytes.lock(); + ripemd160.lock(); + scrypt.lock(); + scryptSync.lock(); + sha256.lock(); + sha512.lock(); +} + +export { lock }; + +///////////////////////////// +// Types + +export type { ProgressCallback } from "./scrypt.js"; + +export type { SignatureLike } from "./signature.js"; diff --git a/src.ts/crypto/keccak.ts b/src.ts/crypto/keccak.ts new file mode 100644 index 000000000..35e38e64b --- /dev/null +++ b/src.ts/crypto/keccak.ts @@ -0,0 +1,26 @@ +import { keccak_256 } from "@noble/hashes/sha3"; + +import { hexlify, logger } from "../utils/index.js"; + +import type { BytesLike } from "../utils/index.js"; + + +let locked = false; + +const _keccak256 = function(data: Uint8Array): Uint8Array { + return keccak_256(data); +} + +let __keccak256: (data: Uint8Array) => BytesLike = _keccak256; + +export function keccak256(_data: BytesLike): string { + const data = logger.getBytes(_data, "data"); + return hexlify(__keccak256(data)); +} +keccak256._ = _keccak256; +keccak256.lock = function(): void { locked = true; } +keccak256.register = function(func: (data: Uint8Array) => BytesLike) { + if (locked) { throw new TypeError("keccak256 is locked"); } + __keccak256 = func; +} +Object.freeze(keccak256); diff --git a/src.ts/crypto/pbkdf2.ts b/src.ts/crypto/pbkdf2.ts new file mode 100644 index 000000000..041d9f954 --- /dev/null +++ b/src.ts/crypto/pbkdf2.ts @@ -0,0 +1,27 @@ +import { pbkdf2Sync } from "./crypto.js"; + +import { hexlify, logger } from "../utils/index.js"; + +import type { BytesLike } from "../utils/index.js"; + + +let locked = false; + +const _pbkdf2 = function(password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512"): BytesLike { + return pbkdf2Sync(password, salt, iterations, keylen, algo); +} + +let __pbkdf2 = _pbkdf2; + +export function pbkdf2(_password: BytesLike, _salt: BytesLike, iterations: number, keylen: number, algo: "sha256" | "sha512"): string { + const password = logger.getBytes(_password, "password"); + const salt = logger.getBytes(_salt, "salt"); + return hexlify(__pbkdf2(password, salt, iterations, keylen, algo)); +} +pbkdf2._ = _pbkdf2; +pbkdf2.lock = function(): void { locked = true; } +pbkdf2.register = function(func: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512") => BytesLike) { + if (locked) { throw new Error("pbkdf2 is locked"); } + __pbkdf2 = func; +} +Object.freeze(pbkdf2); diff --git a/src.ts/crypto/random.ts b/src.ts/crypto/random.ts new file mode 100644 index 000000000..72fb619d9 --- /dev/null +++ b/src.ts/crypto/random.ts @@ -0,0 +1,21 @@ +import { randomBytes as crypto_random } from "./crypto.js"; + +let locked = false; + +const _randomBytes = function(length: number): Uint8Array { + return new Uint8Array(crypto_random(length)); +} + +let __randomBytes = _randomBytes; + +export function randomBytes(length: number): Uint8Array { + return __randomBytes(length); +} + +randomBytes._ = _randomBytes; +randomBytes.lock = function(): void { locked = true; } +randomBytes.register = function(func: (length: number) => Uint8Array) { + if (locked) { throw new Error("random is locked"); } + __randomBytes = func; +} +Object.freeze(randomBytes); diff --git a/src.ts/crypto/ripemd160.ts b/src.ts/crypto/ripemd160.ts new file mode 100644 index 000000000..55ffcfc65 --- /dev/null +++ b/src.ts/crypto/ripemd160.ts @@ -0,0 +1,26 @@ +import { ripemd160 as noble_ripemd160 } from "@noble/hashes/ripemd160"; + +import { hexlify, logger } from "../utils/index.js"; + +import type { BytesLike } from "../utils/index.js"; + + +let locked = false; + +const _ripemd160 = function(data: Uint8Array): Uint8Array { + return noble_ripemd160(data); +} + +let __ripemd160: (data: Uint8Array) => BytesLike = _ripemd160; + +export function ripemd160(_data: BytesLike): string { + const data = logger.getBytes(_data, "data"); + return hexlify(__ripemd160(data)); +} +ripemd160._ = _ripemd160; +ripemd160.lock = function(): void { locked = true; } +ripemd160.register = function(func: (data: Uint8Array) => BytesLike) { + if (locked) { throw new TypeError("ripemd160 is locked"); } + __ripemd160 = func; +} +Object.freeze(ripemd160); diff --git a/src.ts/crypto/scrypt.ts b/src.ts/crypto/scrypt.ts new file mode 100644 index 000000000..83f5e0778 --- /dev/null +++ b/src.ts/crypto/scrypt.ts @@ -0,0 +1,48 @@ +import { scrypt as _nobleSync, scryptAsync as _nobleAsync } from "@noble/hashes/scrypt"; + +import { hexlify as H, logger } from "../utils/index.js"; + +import type { BytesLike } from "../utils/index.js"; + + +export type ProgressCallback = (percent: number) => void; + + +let lockedSync = false, lockedAsync = false; + +const _scryptAsync = async function(passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number, onProgress?: ProgressCallback) { + return await _nobleAsync(passwd, salt, { N, r, p, dkLen, onProgress }); +} +const _scryptSync = function(passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number) { + return _nobleSync(passwd, salt, { N, r, p, dkLen }); +} + +let __scryptAsync: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number, onProgress?: ProgressCallback) => Promise = _scryptAsync; +let __scryptSync: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number) => BytesLike = _scryptSync + + +export async function scrypt(_passwd: BytesLike, _salt: BytesLike, N: number, r: number, p: number, dkLen: number, progress?: ProgressCallback): Promise { + const passwd = logger.getBytes(_passwd, "passwd"); + const salt = logger.getBytes(_salt, "salt"); + return H(await __scryptAsync(passwd, salt, N, r, p, dkLen, progress)); +} +scrypt._ = _scryptAsync; +scrypt.lock = function(): void { lockedAsync = true; } +scrypt.register = function(func: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number, progress?: ProgressCallback) => Promise) { + if (lockedAsync) { throw new Error("scrypt is locked"); } + __scryptAsync = func; +} +Object.freeze(scrypt); + +export function scryptSync(_passwd: BytesLike, _salt: BytesLike, N: number, r: number, p: number, dkLen: number): string { + const passwd = logger.getBytes(_passwd, "passwd"); + const salt = logger.getBytes(_salt, "salt"); + return H(__scryptSync(passwd, salt, N, r, p, dkLen)); +} +scryptSync._ = _scryptSync; +scryptSync.lock = function(): void { lockedSync = true; } +scryptSync.register = function(func: (passwd: Uint8Array, salt: Uint8Array, N: number, r: number, p: number, dkLen: number) => BytesLike) { + if (lockedSync) { throw new Error("scryptSync is locked"); } + __scryptSync = func; +} +Object.freeze(scryptSync); diff --git a/src.ts/crypto/sha2.ts b/src.ts/crypto/sha2.ts new file mode 100644 index 000000000..6369fe3f5 --- /dev/null +++ b/src.ts/crypto/sha2.ts @@ -0,0 +1,44 @@ +import { createHash } from "./crypto.js"; + +import { hexlify, logger } from "../utils/index.js"; + +import type { BytesLike } from "../utils/index.js"; + + +const _sha256 = function(data: Uint8Array): Uint8Array { + return createHash("sha256").update(data).digest(); +} + +const _sha512 = function(data: Uint8Array): Uint8Array { + return createHash("sha512").update(data).digest(); +} + +let __sha256: (data: Uint8Array) => BytesLike = _sha256; +let __sha512: (data: Uint8Array) => BytesLike = _sha512; + +let locked256 = false, locked512 = false; + + +export function sha256(_data: BytesLike): string { + const data = logger.getBytes(_data, "data"); + return hexlify(__sha256(data)); +} +sha256._ = _sha256; +sha256.lock = function(): void { locked256 = true; } +sha256.register = function(func: (data: Uint8Array) => BytesLike): void { + if (locked256) { throw new Error("sha256 is locked"); } + __sha256 = func; +} +Object.freeze(sha256); + +export function sha512(_data: BytesLike): string { + const data = logger.getBytes(_data, "data"); + return hexlify(__sha512(data)); +} +sha512._ = _sha512; +sha512.lock = function(): void { locked512 = true; } +sha512.register = function(func: (data: Uint8Array) => BytesLike): void { + if (locked512) { throw new Error("sha512 is locked"); } + __sha512 = func; +} +Object.freeze(sha256); diff --git a/src.ts/crypto/signature.ts b/src.ts/crypto/signature.ts new file mode 100644 index 000000000..0de2c1a33 --- /dev/null +++ b/src.ts/crypto/signature.ts @@ -0,0 +1,261 @@ +import { ZeroHash } from "../constants/index.js"; +import { + concat, dataLength, getStore, hexlify, isHexString, logger, setStore +} from "../utils/index.js"; + +import type { BigNumberish, BytesLike, Freezable, Frozen } from "../utils/index.js"; + + +// Constants +const BN_0 = BigInt(0); +const BN_1 = BigInt(1); +const BN_2 = BigInt(2); +const BN_27 = BigInt(27); +const BN_28 = BigInt(28); +const BN_35 = BigInt(35); + + +const _guard = { }; + + +export type SignatureLike = Signature | string | { + r: string; + s: string; + v: BigNumberish; + yParity?: 0 | 1; + yParityAndS?: string; +} | { + r: string; + yParityAndS: string; + yParity?: 0 | 1; + s?: string; + v?: number; +} | { + r: string; + s: string; + yParity: 0 | 1; + v?: BigNumberish; + yParityAndS?: string; +}; + + +export class Signature implements Freezable { + #props: { r: string, s: string, v: 27 | 28, networkV: null | bigint }; + + get r(): string { return getStore(this.#props, "r"); } + set r(value: BytesLike) { + if (dataLength(value) !== 32) { + logger.throwArgumentError("invalid r", "value", value); + } + setStore(this.#props, "r", hexlify(value)); + } + + get s(): string { return getStore(this.#props, "s"); } + set s(value: BytesLike) { + if (dataLength(value) !== 32) { + logger.throwArgumentError("invalid r", "value", value); + } else if (logger.getBytes(value)[0] & 0x80) { + logger.throwArgumentError("non-canonical s", "value", value); + } + setStore(this.#props, "s", hexlify(value)); + } + + get v(): 27 | 28 { return getStore(this.#props, "v"); } + set v(value: BigNumberish) { + const v = logger.getNumber(value, "value"); + if (v !== 27 && v !== 28) { throw new Error("@TODO"); } + setStore(this.#props, "v", v); + } + + get networkV(): null | bigint { return getStore(this.#props, "networkV"); } + get legacyChainId(): null | bigint { + const v = this.networkV; + if (v == null) { return null; } + return Signature.getChainId(v); + } + + get yParity(): 0 | 1 { + if (this.v === 27) { return 0; } + return 1; + /* + // When v is 0 or 1 it is the recid directly + if (this.v.isZero()) { return 0; } + if (this.v.eq(1)) { return 1; } + + // Otherwise, odd (e.g. 27) is 0 and even (e.g. 28) is 1 + return this.v.and(1).isZero() ? 1: 0; + */ + } + + get yParityAndS(): string { + // The EIP-2098 compact representation + const yParityAndS = logger.getBytes(this.s); + if (this.yParity) { yParityAndS[0] |= 0x80; } + return hexlify(yParityAndS); + } + + get compactSerialized(): string { + return concat([ this.r, this.yParityAndS ]); + } + + get serialized(): string { + return concat([ this.r, this.s, (this.yParity ? "0x1c": "0x1b") ]); + } + + constructor(guard: any, r: string, s: string, v: 27 | 28) { + logger.assertPrivate(guard, _guard, "Signature"); + this.#props = { r, s, v, networkV: null }; + } + + [Symbol.for('nodejs.util.inspect.custom')]() { + return `Signature { r: "${ this.r }", s: "${ this.s }", yParity: ${ this.yParity }, networkV: ${ this.networkV } }`; + } + + clone(): Signature { + const clone = new Signature(_guard, this.r, this.s, this.v); + if (this.networkV) { setStore(clone.#props, "networkV", this.networkV); } + return clone; + } + + freeze(): Frozen { + Object.freeze(this.#props); + return this; + } + + isFrozen(): boolean { + return Object.isFrozen(this.#props); + } + + toJSON(): any { + const networkV = this.networkV; + return { + _type: "signature", + networkV: ((networkV != null) ? networkV.toString(): null), + r: this.r, s: this.s, v: this.v, + }; + } + + static create(): Signature { + return new Signature(_guard, ZeroHash, ZeroHash, 27); + } + + // Get the chain ID from an EIP-155 v + static getChainId(v: BigNumberish): bigint { + const bv = logger.getBigInt(v, "v"); + + // The v is not an EIP-155 v, so it is the unspecified chain ID + if ((bv == BN_27) || (bv == BN_28)) { return BN_0; } + + // Bad value for an EIP-155 v + if (bv < BN_35) { logger.throwArgumentError("invalid EIP-155 v", "v", v); } + + return (bv - BN_35) / BN_2; + } + + // Get the EIP-155 v transformed for a given chainId + static getChainIdV(chainId: BigNumberish, v: 27 | 28): bigint { + return (logger.getBigInt(chainId) * BN_2) + BigInt(35 + v - 27); + } + + // Convert an EIP-155 v into a normalized v + static getNormalizedV(v: BigNumberish): 27 | 28 { + const bv = logger.getBigInt(v); + + if (bv == BN_0) { return 27; } + if (bv == BN_1) { return 28; } + + // Otherwise, EIP-155 v means odd is 27 and even is 28 + return (bv & BN_1) ? 27: 28; + } + + static from(sig: SignatureLike): Signature { + const throwError = (message: string) => { + return logger.throwArgumentError(message, "signature", sig); + }; + + if (typeof(sig) === "string") { + const bytes = logger.getBytes(sig, "signature"); + if (bytes.length === 64) { + const r = hexlify(bytes.slice(0, 32)); + const s = bytes.slice(32, 64); + const v = (s[0] & 0x80) ? 28: 27; + s[0] &= 0x7f; + return new Signature(_guard, r, hexlify(s), v); + } + + if (dataLength(sig) !== 65) { + const r = hexlify(sig.slice(0, 32)); + const s = bytes.slice(32, 64); + if (s[0] & 0x80) { throwError("non-canonical s"); } + const v = Signature.getNormalizedV(bytes[64]); + return new Signature(_guard, r, hexlify(s), v); + } + + return throwError("invlaid raw signature length"); + } + + if (sig instanceof Signature) { return sig.clone(); } + + // Get r + const r = sig.r; + if (r == null) { throwError("missing r"); } + if (!isHexString(r, 32)) { throwError("invalid r"); } + + // Get s; by any means necessary (we check consistency below) + const s = (function(s?: string, yParityAndS?: string) { + if (s != null) { + if (!isHexString(s, 32)) { throwError("invalid s"); } + return s; + } + + if (yParityAndS != null) { + if (!isHexString(yParityAndS, 32)) { throwError("invalid yParityAndS"); } + const bytes = logger.getBytes(yParityAndS); + bytes[0] &= 0x7f; + return hexlify(bytes); + } + + return throwError("missing s"); + })(sig.s, sig.yParityAndS); + if (logger.getBytes(s)[0] & 0x80) { throwError("non-canonical s"); } + + // Get v; by any means necessary (we check consistency below) + const { networkV, v } = (function(_v?: BigNumberish, yParityAndS?: string, yParity?: number): { networkV?: bigint, v: 27 | 28 } { + if (_v != null) { + const v = logger.getBigInt(_v); + return { + networkV: ((v >= BN_35) ? v: undefined), + v: Signature.getNormalizedV(v) + }; + } + + if (yParityAndS != null) { + if (!isHexString(yParityAndS, 32)) { throwError("invalid yParityAndS"); } + return { v: ((logger.getBytes(yParityAndS)[0] & 0x80) ? 28: 27) }; + } + + if (yParity != null) { + switch (yParity) { + case 0: return { v: 27 }; + case 1: return { v: 28 }; + } + return throwError("invalid yParity"); + } + + return throwError("missing v"); + })(sig.v, sig.yParityAndS, sig.yParity); + + const result = new Signature(_guard, r, s, v); + if (networkV) { setStore(result.#props, "networkV", networkV); } + + // If multiple of v, yParity, yParityAndS we given, check they match + if ("yParity" in sig && sig.yParity !== result.yParity) { + throwError("yParity mismatch"); + } else if ("yParityAndS" in sig && sig.yParityAndS !== result.yParityAndS) { + throwError("yParityAndS mismatch"); + } + + return result; + } +} + diff --git a/src.ts/crypto/signing-key.ts b/src.ts/crypto/signing-key.ts new file mode 100644 index 000000000..4aeb24b77 --- /dev/null +++ b/src.ts/crypto/signing-key.ts @@ -0,0 +1,130 @@ + +import * as secp256k1 from "@noble/secp256k1"; + +import { computeHmac } from "../crypto/index.js"; +import { concat, hexlify, toHex, logger } from "../utils/index.js"; + +import { Signature } from "./signature.js"; + +import type { BytesLike, Frozen } from "../utils/index.js"; + +import type { SignatureLike } from "./index.js"; + + +//const N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"); + +// Make noble-secp256k1 sync +secp256k1.utils.hmacSha256Sync = function(key: Uint8Array, ...messages: Array): Uint8Array { + return logger.getBytes(computeHmac("sha256", key, concat(messages))); +} + +export class SigningKey { + #privateKey: string; + + constructor(privateKey: BytesLike) { + /* @TODO + logger.assertArgument(() => { + if (dataLength(privateKey) !== 32) { throw new Error("bad length"); } + return toBigInt(privateKey) < N; + }, "invalid private key", "privateKey", "[REDACTED]"); + */ + this.#privateKey = hexlify(privateKey); + } + + get privateKey(): string { return this.#privateKey; } + get publicKey(): string { return SigningKey.computePublicKey(this.#privateKey); } + get compressedPublicKey(): string { return SigningKey.computePublicKey(this.#privateKey, true); } + + sign(digest: BytesLike): Frozen { + /* @TODO + logger.assertArgument(() => (dataLength(digest) === 32), "invalid digest length", "digest", digest); + */ + + const [ sigDer, recid ] = secp256k1.signSync(logger.getBytesCopy(digest), logger.getBytesCopy(this.#privateKey), { + recovered: true, + canonical: true + }); + + const sig = secp256k1.Signature.fromHex(sigDer); + + return Signature.from({ + r: toHex("0x" + sig.r.toString(16), 32), + s: toHex("0x" + sig.s.toString(16), 32), + v: (recid ? 0x1c: 0x1b) + }).freeze(); + } + + computeShardSecret(other: BytesLike): string { + const pubKey = SigningKey.computePublicKey(other); + return hexlify(secp256k1.getSharedSecret(logger.getBytesCopy(this.#privateKey), pubKey)); + } + + static computePublicKey(key: BytesLike, compressed?: boolean): string { + let bytes = logger.getBytes(key, "key"); + + if (bytes.length === 32) { + const pubKey = secp256k1.getPublicKey(bytes, !!compressed); + return hexlify(pubKey); + } + + if (bytes.length === 64) { + const pub = new Uint8Array(65); + pub[0] = 0x04; + pub.set(bytes, 1); + bytes = pub; + } + + const point = secp256k1.Point.fromHex(bytes); + return hexlify(point.toRawBytes(compressed)); + } + + static recoverPublicKey(digest: BytesLike, signature: SignatureLike): string { + const sig = Signature.from(signature); + const der = secp256k1.Signature.fromCompact(logger.getBytesCopy(concat([ sig.r, sig.s ]))).toDERRawBytes(); + + const pubKey = secp256k1.recoverPublicKey(logger.getBytesCopy(digest), der, sig.yParity); + if (pubKey != null) { return hexlify(pubKey); } + + return logger.throwArgumentError("invalid signautre for digest", "signature", signature); + } + + static _addPoints(p0: BytesLike, p1: BytesLike, compressed?: boolean): string { + const pub0 = secp256k1.Point.fromHex(SigningKey.computePublicKey(p0).substring(2)); + const pub1 = secp256k1.Point.fromHex(SigningKey.computePublicKey(p1).substring(2)); + return "0x" + pub0.add(pub1).toHex(!!compressed) + } +} + +/* +const key = new SigningKey("0x1234567890123456789012345678901234567890123456789012345678901234"); +console.log(key); +console.log(key.sign("0x1234567890123456789012345678901234567890123456789012345678901234")); +{ + const privKey = "0x1234567812345678123456781234567812345678123456781234567812345678"; + const signingKey = new SigningKey(privKey); + console.log("0", signingKey, signingKey.publicKey, signingKey.publicKeyCompressed); + + let pubKey = SigningKey.computePublicKey(privKey); + let pubKeyComp = SigningKey.computePublicKey(privKey, true); + let pubKeyRaw = "0x" + SigningKey.computePublicKey(privKey).substring(4); + console.log("A", pubKey, pubKeyComp); + + let a = SigningKey.computePublicKey(pubKey); + let b = SigningKey.computePublicKey(pubKey, true); + console.log("B", a, b); + + a = SigningKey.computePublicKey(pubKeyComp); + b = SigningKey.computePublicKey(pubKeyComp, true); + console.log("C", a, b); + + a = SigningKey.computePublicKey(pubKeyRaw); + b = SigningKey.computePublicKey(pubKeyRaw, true); + console.log("D", a, b); + + const digest = "0x1122334411223344112233441122334411223344112233441122334411223344"; + const sig = signingKey.sign(digest); + console.log("SS", sig, sig.r, sig.s, sig.yParity); + + console.log("R", SigningKey.recoverPublicKey(digest, sig)); +} +*/ diff --git a/src.ts/ethers.ts b/src.ts/ethers.ts new file mode 100644 index 000000000..98982b11a --- /dev/null +++ b/src.ts/ethers.ts @@ -0,0 +1,147 @@ + + +///////////////////////////// +// + +export { version } from "./_version.js"; + +export { + formatBytes32String, parseBytes32String, + + AbiCoder, defaultAbiCoder, + ConstructorFragment, ErrorFragment, EventFragment, Fragment, FunctionFragment, ParamType, + + checkResultErrors, Indexed, Interface, LogDescription, Result, TransactionDescription, + Typed, +} from "./abi/index.js"; + +export { + getAddress, getIcapAddress, + getCreateAddress, getCreate2Address +} from "./address/index.js"; + +export { + ZeroAddress, + NegativeOne, Zero, One, Two, WeiPerEther, MaxUint256, MinInt256, MaxInt256, + ZeroHash, + EtherSymbol, MessagePrefix +} from "./constants/index.js"; + +export { + BaseContract, Contract, + ContractFactory, + ContractEventPayload, ContractTransactionReceipt, ContractTransactionResponse, EventLog, +} from "./contract/index.js"; + +export { + computeHmac, + randomBytes, + keccak256, + ripemd160, + sha256, sha512, + pbkdf2, + scrypt, scryptSync, + lock, + Signature, SigningKey +} from "./crypto/index.js"; + +export { + id, + //isValidName, namehash, dnsEncode + hashMessage, + solidityPacked, solidityPackedKeccak256, solidityPackedSha256, + TypedDataEncoder +} from "./hash/index.js"; + + +export { + accessListify, + computeAddress, recoverAddress, + Transaction +} from "./transaction/index.js"; + +export { + decodeBase58, encodeBase58, + isCallException, isError, + FetchRequest, FetchResponse, + FixedFormat, FixedNumber, formatFixed, parseFixed, + assertArgument, Logger, logger, + fromTwos, toTwos, mask, toArray, toBigInt, toHex, toNumber, + formatEther, parseEther, formatUnits, parseUnits, + _toEscapedUtf8String, toUtf8Bytes, toUtf8CodePoints, toUtf8String, + Utf8ErrorFuncs, + decodeRlp, encodeRlp +} from "./utils/index.js"; + +export { + defaultPath, + getAccountPath, + HDNodeWallet, HDNodeVoidWallet, HDNodeWalletManager, + isCrowdsaleJson, decryptCrowdsaleJson, + isKeystoreJson, decryptKeystoreJsonSync, decryptKeystoreJson, + encryptKeystoreJson, + Mnemonic, + Wallet +} from "./wallet/index.js"; + +export { + Wordlist, langEn, LangEn, wordlists, WordlistOwl, WordlistOwlA +} from "./wordlists/index.js"; + + + +///////////////////////////// +// Types + +export type { + JsonFragment, JsonFragmentType, + InterfaceAbi, +} from "./abi/index.js"; + +export type { Addressable } from "./address/index.js"; + +export type { + ConstantContractMethod, ContractEvent, ContractEventArgs, ContractEventName, + ContractInterface, ContractMethod, ContractMethodArgs, ContractTransaction, + DeferredTopicFilter, Overrides +} from "./contract/index.js"; + +export type { ProgressCallback, SignatureLike } from "./crypto/index.js"; + +export type { TypedDataDomain, TypedDataField } from "./hash/index.js"; + +export { + FallbackProvider, + JsonRpcApiProvider, JsonRpcProvider, JsonRpcSigner, + + AlchemyProvider, AnkrProvider, CloudflareProvider, EtherscanProvider, InfuraProvider, + //PocketProvider } from "./provider-pocket.js"; + + IpcSocketProvider, SocketProvider, WebSocketProvider, + + Network +} from "./providers/index.js"; + +export type { + AccessList, AccessListish, AccessListSet, + SignedTransaction, TransactionLike +} from "./transaction/index.js"; + +export type { + BytesLike, + BigNumberish, Numeric, + ErrorCode, + Utf8ErrorFunc, UnicodeNormalizationForm, Utf8ErrorReason, + RlpStructuredData, + + GetUrlResponse, + FetchRequestWithBody, FetchResponseWithBody, + FetchPreflightFunc, FetchProcessFunc, FetchRetryFunc, + FetchGatewayFunc, FetchGetUrlFunc +} from "./utils/index.js"; + +export type { + KeystoreAccountParams, KeystoreAccount, + EncryptOptions +} from "./wallet/index.js"; + diff --git a/src.ts/hash/id.ts b/src.ts/hash/id.ts new file mode 100644 index 000000000..8b0f08185 --- /dev/null +++ b/src.ts/hash/id.ts @@ -0,0 +1,6 @@ +import { keccak256 } from "../crypto/keccak.js"; +import { toUtf8Bytes } from "../utils/index.js"; + +export function id(value: string): string { + return keccak256(toUtf8Bytes(value)); +} diff --git a/src.ts/hash/index.ts b/src.ts/hash/index.ts new file mode 100644 index 000000000..6452a4940 --- /dev/null +++ b/src.ts/hash/index.ts @@ -0,0 +1,10 @@ + +export { id } from "./id.js" +export { isValidName, namehash, dnsEncode } from "./namehash.js"; +export { hashMessage } from "./message.js"; +export { + solidityPacked, solidityPackedKeccak256, solidityPackedSha256 +} from "./solidity.js"; +export { TypedDataEncoder } from "./typed-data.js"; + +export type { TypedDataDomain, TypedDataField } from "./typed-data.js"; diff --git a/src.ts/hash/message.ts b/src.ts/hash/message.ts new file mode 100644 index 000000000..f2c959738 --- /dev/null +++ b/src.ts/hash/message.ts @@ -0,0 +1,13 @@ +import { keccak256 } from "../crypto/keccak.js"; +import { MessagePrefix } from "../constants/index.js"; +import { concat, toUtf8Bytes } from "../utils/index.js"; + + +export function hashMessage(message: Uint8Array | string): string { + if (typeof(message) === "string") { message = toUtf8Bytes(message); } + return keccak256(concat([ + toUtf8Bytes(MessagePrefix), + toUtf8Bytes(String(message.length)), + message + ])); +} diff --git a/src.ts/hash/namehash.ts b/src.ts/hash/namehash.ts new file mode 100644 index 000000000..90dda9fe1 --- /dev/null +++ b/src.ts/hash/namehash.ts @@ -0,0 +1,84 @@ + +import { keccak256 } from "../crypto/keccak.js"; +import { concat, hexlify, logger, toUtf8Bytes, toUtf8String } from "../utils/index.js"; + + +//import { ens_normalize } from "./ens-normalize/lib"; +// @TOOD: +function ens_normalize(name: string): string { + return name; +} + +const Zeros = new Uint8Array(32); +Zeros.fill(0); + +function checkComponent(comp: Uint8Array): Uint8Array { + if (comp.length === 0) { throw new Error("invalid ENS name; empty component"); } + return comp; +} + +function ensNameSplit(name: string): Array { + const bytes = toUtf8Bytes(ens_normalize(name)); + const comps: Array = [ ]; + + if (name.length === 0) { return comps; } + + let last = 0; + for (let i = 0; i < bytes.length; i++) { + const d = bytes[i]; + + // A separator (i.e. "."); copy this component + if (d === 0x2e) { + comps.push(checkComponent(bytes.slice(last, i))); + last = i + 1; + } + } + + // There was a stray separator at the end of the name + if (last >= bytes.length) { throw new Error("invalid ENS name; empty component"); } + + comps.push(checkComponent(bytes.slice(last))); + return comps; +} + +export function ensNormalize(name: string): string { + return ensNameSplit(name).map((comp) => toUtf8String(comp)).join("."); +} + +export function isValidName(name: string): boolean { + try { + return (ensNameSplit(name).length !== 0); + } catch (error) { } + return false; +} + +export function namehash(name: string): string { + /* istanbul ignore if */ + if (typeof(name) !== "string") { + logger.throwArgumentError("invalid ENS name; not a string", "name", name); + } + + let result: string | Uint8Array = Zeros; + + const comps = ensNameSplit(name); + while (comps.length) { + result = keccak256(concat([ result, keccak256((comps.pop()))] )); + } + + return hexlify(result); +} + +export function dnsEncode(name: string): string { + return hexlify(concat(ensNameSplit(name).map((comp) => { + // DNS does not allow components over 63 bytes in length + if (comp.length > 63) { + throw new Error("invalid DNS encoded entry; length exceeds 63 bytes"); + } + + const bytes = new Uint8Array(comp.length + 1); + bytes.set(comp, 1); + bytes[0] = bytes.length - 1; + return bytes; + + }))) + "00"; +} diff --git a/src.ts/hash/solidity.ts b/src.ts/hash/solidity.ts new file mode 100644 index 000000000..ef5705d54 --- /dev/null +++ b/src.ts/hash/solidity.ts @@ -0,0 +1,115 @@ +import { + concat, dataLength, hexlify, logger, toArray, toTwos, toUtf8Bytes, zeroPadBytes, zeroPadValue +} from "../utils/index.js"; +import { keccak256 as _keccak256 } from "../crypto/keccak.js"; +import { sha256 as _sha256 } from "../crypto/sha2.js"; + + +const regexBytes = new RegExp("^bytes([0-9]+)$"); +const regexNumber = new RegExp("^(u?int)([0-9]*)$"); +const regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$"); + + +function _pack(type: string, value: any, isArray?: boolean): Uint8Array { + switch(type) { + case "address": + if (isArray) { return logger.getBytes(zeroPadValue(value, 32)); } + return logger.getBytes(value); + case "string": + return toUtf8Bytes(value); + case "bytes": + return logger.getBytes(value); + case "bool": + value = (!!value ? "0x01": "0x00"); + if (isArray) { return logger.getBytes(zeroPadValue(value, 32)); } + return logger.getBytes(value); + } + + let match = type.match(regexNumber); + if (match) { + let size = parseInt(match[2] || "256") + + if ((match[2] && String(size) !== match[2]) || (size % 8 !== 0) || size === 0 || size > 256) { + return logger.throwArgumentError("invalid number type", "type", type) + } + + if (isArray) { size = 256; } + + value = toTwos(value, size); + + return logger.getBytes(zeroPadValue(toArray(value), size / 8)); + } + + match = type.match(regexBytes); + if (match) { + const size = parseInt(match[1]); + + if (String(size) !== match[1] || size === 0 || size > 32) { + return logger.throwArgumentError("invalid bytes type", "type", type) + } + if (dataLength(value) !== size) { + return logger.throwArgumentError(`invalid value for ${ type }`, "value", value) + } + if (isArray) { return logger.getBytes(zeroPadBytes(value, 32)); } + return value; + } + + match = type.match(regexArray); + if (match && Array.isArray(value)) { + const baseType = match[1]; + const count = parseInt(match[2] || String(value.length)); + if (count != value.length) { + logger.throwArgumentError(`invalid array length for ${ type }`, "value", value) + } + const result: Array = []; + value.forEach(function(value) { + result.push(_pack(baseType, value, true)); + }); + return logger.getBytes(concat(result)); + } + + return logger.throwArgumentError("invalid type", "type", type) +} + +// @TODO: Array Enum + +export function solidityPacked(types: ReadonlyArray, values: ReadonlyArray) { + if (types.length != values.length) { + logger.throwArgumentError("wrong number of values; expected ${ types.length }", "values", values) + } + const tight: Array = []; + types.forEach(function(type, index) { + tight.push(_pack(type, values[index])); + }); + return hexlify(concat(tight)); +} + +/** + * Computes the non-standard packed (tightly packed) keccak256 hash of + * the values given the types. + * + * @param {Array} types - The Solidity types to interpret each value as [default: bar] + * @param {Array} values - The values to pack + * + * @returns: {HexString} the hexstring of the hash + * @example: + * solidityPackedKeccak256([ "address", "uint" ], [ "0x1234", 45 ]); + * //_result: + * + * @see https://docs.soliditylang.org/en/v0.8.14/abi-spec.html#non-standard-packed-mode + */ +export function solidityPackedKeccak256(types: ReadonlyArray, values: ReadonlyArray) { + return _keccak256(solidityPacked(types, values)); +} + +/** + * Test Function, for fun + * + * @param foo - something fun + */ +export function test(foo: number | string): void { +} + +export function solidityPackedSha256(types: ReadonlyArray, values: ReadonlyArray) { + return _sha256(solidityPacked(types, values)); +} diff --git a/src.ts/hash/typed-data.ts b/src.ts/hash/typed-data.ts new file mode 100644 index 000000000..1252800bd --- /dev/null +++ b/src.ts/hash/typed-data.ts @@ -0,0 +1,520 @@ +//import { TypedDataDomain, TypedDataField } from "@ethersproject/providerabstract-signer"; +import { getAddress } from "../address/index.js"; +import { keccak256 } from "../crypto/index.js"; +import { + concat, defineProperties, hexlify, isHexString, mask, toHex, toTwos, zeroPadValue +} from "../utils/index.js"; + +import { id } from "./id.js"; +import { logger } from "../utils/logger.js"; + +import type { BigNumberish, BytesLike } from "../utils/index.js"; + + +const padding = new Uint8Array(32); +padding.fill(0); + +const BN__1 = BigInt(-1); +const BN_0 = BigInt(0); +const BN_1 = BigInt(1); +const BN_MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); + +export interface TypedDataDomain { + name?: string; + version?: string; + chainId?: BigNumberish; + verifyingContract?: string; + salt?: BytesLike; +}; + +export interface TypedDataField { + name: string; + type: string; +}; + +function hexPadRight(value: BytesLike) { + const bytes = logger.getBytes(value); + const padOffset = bytes.length % 32 + if (padOffset) { + return concat([ bytes, padding.slice(padOffset) ]); + } + return hexlify(bytes); +} + +const hexTrue = toHex(BN_1, 32); +const hexFalse = toHex(BN_0, 32); + +const domainFieldTypes: Record = { + name: "string", + version: "string", + chainId: "uint256", + verifyingContract: "address", + salt: "bytes32" +}; + +const domainFieldNames: Array = [ + "name", "version", "chainId", "verifyingContract", "salt" +]; + +function checkString(key: string): (value: any) => string { + return function (value: any){ + if (typeof(value) !== "string") { + logger.throwArgumentError(`invalid domain value for ${ JSON.stringify(key) }`, `domain.${ key }`, value); + } + return value; + } +} + +const domainChecks: Record any> = { + name: checkString("name"), + version: checkString("version"), + chainId: function(value: any) { + return logger.getBigInt(value, "domain.chainId"); + }, + verifyingContract: function(value: any) { + try { + return getAddress(value).toLowerCase(); + } catch (error) { } + return logger.throwArgumentError(`invalid domain value "verifyingContract"`, "domain.verifyingContract", value); + }, + salt: function(value: any) { + const bytes = logger.getBytes(value, "domain.salt"); + if (bytes.length !== 32) { + logger.throwArgumentError(`invalid domain value "salt"`, "domain.salt", value); + } + return hexlify(bytes); + } +} + +function getBaseEncoder(type: string): null | ((value: any) => string) { + // intXX and uintXX + { + const match = type.match(/^(u?)int(\d*)$/); + if (match) { + const signed = (match[1] === ""); + + const width = parseInt(match[2] || "256"); + if (width % 8 !== 0 || width > 256 || (match[2] && match[2] !== String(width))) { + logger.throwArgumentError("invalid numeric width", "type", type); + } + + const boundsUpper = mask(BN_MAX_UINT256, signed ? (width - 1): width); + const boundsLower = signed ? ((boundsUpper + BN_1) * BN__1): BN_0; + + return function(_value: BigNumberish) { + const value = logger.getBigInt(_value, "value"); + + if (value < boundsLower || value > boundsUpper) { + logger.throwArgumentError(`value out-of-bounds for ${ type }`, "value", value); + } + + return toHex(toTwos(value, 256), 32); + }; + } + } + + // bytesXX + { + const match = type.match(/^bytes(\d+)$/); + if (match) { + const width = parseInt(match[1]); + if (width === 0 || width > 32 || match[1] !== String(width)) { + logger.throwArgumentError("invalid bytes width", "type", type); + } + + return function(value: BytesLike) { + const bytes = logger.getBytes(value); + if (bytes.length !== width) { + logger.throwArgumentError(`invalid length for ${ type }`, "value", value); + } + return hexPadRight(value); + }; + } + } + + switch (type) { + case "address": return function(value: string) { + return zeroPadValue(getAddress(value), 32); + }; + case "bool": return function(value: boolean) { + return ((!value) ? hexFalse: hexTrue); + }; + case "bytes": return function(value: BytesLike) { + return keccak256(value); + }; + case "string": return function(value: string) { + return id(value); + }; + } + + return null; +} + +function encodeType(name: string, fields: Array): string { + return `${ name }(${ fields.map(({ name, type }) => (type + " " + name)).join(",") })`; +} + +export class TypedDataEncoder { + readonly primaryType!: string; + + readonly #types: string; + get types(): Record> { + return JSON.parse(this.#types); + } + + readonly #fullTypes: Map + + readonly #encoderCache: Map string>; + + constructor(types: Record>) { + this.#types = JSON.stringify(types); + this.#fullTypes = new Map(); + this.#encoderCache = new Map(); + + // Link struct types to their direct child structs + const links: Map> = new Map(); + + // Link structs to structs which contain them as a child + const parents: Map> = new Map(); + + // Link all subtypes within a given struct + const subtypes: Map> = new Map(); + + Object.keys(types).forEach((type) => { + links.set(type, new Set()); + parents.set(type, [ ]); + subtypes.set(type, new Set()); + }); + + for (const name in types) { + const uniqueNames: Set = new Set(); + + for (const field of types[name]) { + + // Check each field has a unique name + if (uniqueNames.has(field.name)) { + logger.throwArgumentError(`duplicate variable name ${ JSON.stringify(field.name) } in ${ JSON.stringify(name) }`, "types", types); + } + uniqueNames.add(field.name); + + // Get the base type (drop any array specifiers) + const baseType = ((field.type.match(/^([^\x5b]*)(\x5b|$)/)))[1] || null; + if (baseType === name) { + logger.throwArgumentError(`circular type reference to ${ JSON.stringify(baseType) }`, "types", types); + } + + // Is this a base encoding type? + const encoder = getBaseEncoder(baseType); + if (encoder) { continue; } + + if (!parents.has(baseType)) { + logger.throwArgumentError(`unknown type ${ JSON.stringify(baseType) }`, "types", types); + } + + // Add linkage + (parents.get(baseType) as Array).push(name); + (links.get(name) as Set).add(baseType); + } + } + + // Deduce the primary type + const primaryTypes = Array.from(parents.keys()).filter((n) => ((parents.get(n) as Array).length === 0)); + + if (primaryTypes.length === 0) { + logger.throwArgumentError("missing primary type", "types", types); + } else if (primaryTypes.length > 1) { + logger.throwArgumentError(`ambiguous primary types or unused types: ${ primaryTypes.map((t) => (JSON.stringify(t))).join(", ") }`, "types", types); + } + + defineProperties(this, { primaryType: primaryTypes[0] }); + + // Check for circular type references + function checkCircular(type: string, found: Set) { + if (found.has(type)) { + logger.throwArgumentError(`circular type reference to ${ JSON.stringify(type) }`, "types", types); + } + + found.add(type); + + for (const child of (links.get(type) as Set)) { + if (!parents.has(child)) { continue; } + + // Recursively check children + checkCircular(child, found); + + // Mark all ancestors as having this decendant + for (const subtype of found) { + (subtypes.get(subtype) as Set).add(child); + } + } + + found.delete(type); + } + checkCircular(this.primaryType, new Set()); + + // Compute each fully describe type + for (const [ name, set ] of subtypes) { + const st = Array.from(set); + st.sort(); + this.#fullTypes.set(name, encodeType(name, types[name]) + st.map((t) => encodeType(t, types[t])).join("")); + } + } + + getEncoder(type: string): (value: any) => string { + let encoder = this.#encoderCache.get(type); + if (!encoder) { + encoder = this.#getEncoder(type); + this.#encoderCache.set(type, encoder); + } + return encoder; + } + + #getEncoder(type: string): (value: any) => string { + + // Basic encoder type (address, bool, uint256, etc) + { + const encoder = getBaseEncoder(type); + if (encoder) { return encoder; } + } + + // Array + const match = type.match(/^(.*)(\x5b(\d*)\x5d)$/); + if (match) { + const subtype = match[1]; + const subEncoder = this.getEncoder(subtype); + const length = parseInt(match[3]); + return (value: Array) => { + if (length >= 0 && value.length !== length) { + logger.throwArgumentError("array length mismatch; expected length ${ arrayLength }", "value", value); + } + + let result = value.map(subEncoder); + if (this.#fullTypes.has(subtype)) { + result = result.map(keccak256); + } + + return keccak256(concat(result)); + }; + } + + // Struct + const fields = this.types[type]; + if (fields) { + const encodedType = id(this.#fullTypes.get(type) as string); + return (value: Record) => { + const values = fields.map(({ name, type }) => { + const result = this.getEncoder(type)(value[name]); + if (this.#fullTypes.has(type)) { return keccak256(result); } + return result; + }); + values.unshift(encodedType); + return concat(values); + } + } + + return logger.throwArgumentError(`unknown type: ${ type }`, "type", type); + } + + encodeType(name: string): string { + const result = this.#fullTypes.get(name); + if (!result) { + return logger.throwArgumentError(`unknown type: ${ JSON.stringify(name) }`, "name", name); + } + return result; + } + + encodeData(type: string, value: any): string { + return this.getEncoder(type)(value); + } + + hashStruct(name: string, value: Record): string { + return keccak256(this.encodeData(name, value)); + } + + encode(value: Record): string { + return this.encodeData(this.primaryType, value); + } + + hash(value: Record): string { + return this.hashStruct(this.primaryType, value); + } + + _visit(type: string, value: any, callback: (type: string, data: any) => any): any { + // Basic encoder type (address, bool, uint256, etc) + { + const encoder = getBaseEncoder(type); + if (encoder) { return callback(type, value); } + } + + // Array + const match = type.match(/^(.*)(\x5b(\d*)\x5d)$/); + if (match) { + const subtype = match[1]; + const length = parseInt(match[3]); + if (length >= 0 && value.length !== length) { + logger.throwArgumentError("array length mismatch; expected length ${ arrayLength }", "value", value); + } + return value.map((v: any) => this._visit(subtype, v, callback)); + } + + // Struct + const fields = this.types[type]; + if (fields) { + return fields.reduce((accum, { name, type }) => { + accum[name] = this._visit(type, value[name], callback); + return accum; + }, >{}); + } + + return logger.throwArgumentError(`unknown type: ${ type }`, "type", type); + } + + visit(value: Record, callback: (type: string, data: any) => any): any { + return this._visit(this.primaryType, value, callback); + } + + static from(types: Record>): TypedDataEncoder { + return new TypedDataEncoder(types); + } + + static getPrimaryType(types: Record>): string { + return TypedDataEncoder.from(types).primaryType; + } + + static hashStruct(name: string, types: Record>, value: Record): string { + return TypedDataEncoder.from(types).hashStruct(name, value); + } + + static hashDomain(domain: TypedDataDomain): string { + const domainFields: Array = [ ]; + for (const name in domain) { + const type = domainFieldTypes[name]; + if (!type) { + logger.throwArgumentError(`invalid typed-data domain key: ${ JSON.stringify(name) }`, "domain", domain); + } + domainFields.push({ name, type }); + } + + domainFields.sort((a, b) => { + return domainFieldNames.indexOf(a.name) - domainFieldNames.indexOf(b.name); + }); + + return TypedDataEncoder.hashStruct("EIP712Domain", { EIP712Domain: domainFields }, domain); + } + + static encode(domain: TypedDataDomain, types: Record>, value: Record): string { + return concat([ + "0x1901", + TypedDataEncoder.hashDomain(domain), + TypedDataEncoder.from(types).hash(value) + ]); + } + + static hash(domain: TypedDataDomain, types: Record>, value: Record): string { + return keccak256(TypedDataEncoder.encode(domain, types, value)); + } + + // Replaces all address types with ENS names with their looked up address + static async resolveNames(domain: TypedDataDomain, types: Record>, value: Record, resolveName: (name: string) => Promise): Promise<{ domain: TypedDataDomain, value: any }> { + // Make a copy to isolate it from the object passed in + domain = Object.assign({ }, domain); + + // Look up all ENS names + const ensCache: Record = { }; + + // Do we need to look up the domain's verifyingContract? + if (domain.verifyingContract && !isHexString(domain.verifyingContract, 20)) { + ensCache[domain.verifyingContract] = "0x"; + } + + // We are going to use the encoder to visit all the base values + const encoder = TypedDataEncoder.from(types); + + // Get a list of all the addresses + encoder.visit(value, (type: string, value: any) => { + if (type === "address" && !isHexString(value, 20)) { + ensCache[value] = "0x"; + } + return value; + }); + + // Lookup each name + for (const name in ensCache) { + ensCache[name] = await resolveName(name); + } + + // Replace the domain verifyingContract if needed + if (domain.verifyingContract && ensCache[domain.verifyingContract]) { + domain.verifyingContract = ensCache[domain.verifyingContract]; + } + + // Replace all ENS names with their address + value = encoder.visit(value, (type: string, value: any) => { + if (type === "address" && ensCache[value]) { return ensCache[value]; } + return value; + }); + + return { domain, value }; + } + + static getPayload(domain: TypedDataDomain, types: Record>, value: Record): any { + // Validate the domain fields + TypedDataEncoder.hashDomain(domain); + + // Derive the EIP712Domain Struct reference type + const domainValues: Record = { }; + const domainTypes: Array<{ name: string, type:string }> = [ ]; + + domainFieldNames.forEach((name) => { + const value = (domain)[name]; + if (value == null) { return; } + domainValues[name] = domainChecks[name](value); + domainTypes.push({ name, type: domainFieldTypes[name] }); + }); + + const encoder = TypedDataEncoder.from(types); + + const typesWithDomain = Object.assign({ }, types); + if (typesWithDomain.EIP712Domain) { + logger.throwArgumentError("types must not contain EIP712Domain type", "types.EIP712Domain", types); + } else { + typesWithDomain.EIP712Domain = domainTypes; + } + + // Validate the data structures and types + encoder.encode(value); + + return { + types: typesWithDomain, + domain: domainValues, + primaryType: encoder.primaryType, + message: encoder.visit(value, (type: string, value: any) => { + + // bytes + if (type.match(/^bytes(\d*)/)) { + return hexlify(logger.getBytes(value)); + } + + // uint or int + if (type.match(/^u?int/)) { + return logger.getBigInt(value).toString(); + } + + switch (type) { + case "address": + return value.toLowerCase(); + case "bool": + return !!value; + case "string": + if (typeof(value) !== "string") { + logger.throwArgumentError(`invalid string`, "value", value); + } + return value; + } + + return logger.throwArgumentError("unsupported type", "type", type); + }) + }; + } +} + diff --git a/src.ts/index.ts b/src.ts/index.ts new file mode 100644 index 000000000..7e55b4067 --- /dev/null +++ b/src.ts/index.ts @@ -0,0 +1,6 @@ + +import * as ethers from "./ethers.js"; + +export { ethers }; + +export * from "./ethers.js"; diff --git a/src.ts/providers/abstract-provider.ts b/src.ts/providers/abstract-provider.ts new file mode 100644 index 000000000..707d00e81 --- /dev/null +++ b/src.ts/providers/abstract-provider.ts @@ -0,0 +1,1314 @@ +// @TODO +// Event coalescence +// When we register an event with an async value (e.g. address is a Signer +// or ENS name), we need to add it immeidately for the Event API, but also +// need time to resolve the address. Upon resolving the address, we need to +// migrate the listener to the static event. We also need to maintain a map +// of Signer/ENS name to address so we can sync respond to listenerCount. + +import { resolveAddress } from "../address/index.js"; +import { concat, dataLength, dataSlice, hexlify, isHexString } from "../utils/data.js"; +import { isCallException } from "../utils/errors.js"; +import { FetchRequest } from "../utils/fetch.js"; +import { toArray, toQuantity } from "../utils/maths.js"; +import { defineProperties, EventPayload, resolveProperties } from "../utils/index.js"; +import { toUtf8String } from "../utils/index.js";; + +import { logger } from "../utils/logger.js"; + +import { EnsResolver } from "./ens-resolver.js"; +import { Network } from "./network.js"; +import { Block, FeeData, Log, TransactionReceipt, TransactionResponse } from "./provider.js"; +import { + PollingBlockSubscriber, PollingEventSubscriber, PollingOrphanSubscriber, PollingTransactionSubscriber +} from "./subscriber-polling.js"; + +import type { Addressable, AddressLike } from "../address/index.js"; +import type { BigNumberish, BytesLike } from "../utils/index.js"; +import type { Frozen, Listener } from "../utils/index.js"; +import type { AccessList } from "../transaction/index.js"; + +import type { Networkish } from "./network.js"; +//import type { MaxPriorityFeePlugin } from "./plugins-network.js"; +import type { + BlockTag, CallRequest, EventFilter, Filter, FilterByBlockHash, + LogParams, OrphanFilter, Provider, ProviderEvent, TransactionRequest, +} from "./provider.js"; + + +// Constants +const BN_2 = BigInt(2); + +const MAX_CCIP_REDIRECTS = 10; + + +function getTag(prefix: string, value: any): string { + return prefix + ":" + JSON.stringify(value, (k, v) => { + if (typeof(v) === "bigint") { return `bigint:${ v.toString() }`} + if (typeof(v) === "string") { return v.toLowerCase(); } + + // Sort object keys + if (typeof(v) === "object" && !Array.isArray(v)) { + const keys = Object.keys(v); + keys.sort(); + return keys.reduce((accum, key) => { + accum[key] = v[key]; + return accum; + }, { }); + } + + return v; + }); +} + +// Only sub-classes overriding the _getSubscription method will care about this +export type Subscription = { + type: "block" | "close" | "debug" | "network" | "pending", + tag: string +} | { + type: "transaction", + tag: string, + hash: string +} | { + type: "event", + tag: string, + filter: EventFilter +} | { + type: "orphan", + tag: string, + filter: OrphanFilter +}; + +export interface Subscriber { + start(): void; + stop(): void; + + pause(dropWhilePaused?: boolean): void; + resume(): void; + + // Subscribers which use polling should implement this to allow + // Providers the ability to update underlying polling intervals + // If not supported, accessing this property should return undefined + pollingInterval?: number; +} + +export class UnmanagedSubscriber implements Subscriber { + name!: string; + + constructor(name: string) { defineProperties(this, { name }); } + + start(): void { } + stop(): void { } + + pause(dropWhilePaused?: boolean): void { } + resume(): void { } +} + +type Sub = { + tag: string; + nameMap: Map + addressableMap: WeakMap; + listeners: Array<{ listener: Listener, once: boolean }>; + started: boolean; + subscriber: Subscriber; +}; + +function copy(value: T): T { + return JSON.parse(JSON.stringify(value)); +} + +function concisify(items: Array): Array { + items = Array.from((new Set(items)).values()) + items.sort(); + return items; +} + +// Normalize a ProviderEvent into a Subscription +// @TODO: Make events sync if possible; like block +//function getSyncSubscription(_event: ProviderEvent): Subscription { +//} + +async function getSubscription(_event: ProviderEvent, provider: AbstractProvider): Promise { + if (_event == null) { throw new Error("invalid event"); } + + // Normalize topic array info an EventFilter + if (Array.isArray(_event)) { _event = { topics: _event }; } + + if (typeof(_event) === "string") { + switch (_event) { + case "block": case "pending": case "debug": case "network": { + return { type: _event, tag: _event }; + } + } + } + + if (isHexString(_event, 32)) { + const hash = _event.toLowerCase(); + return { type: "transaction", tag: getTag("tx", { hash }), hash }; + } + + if ((_event).orphan) { + const event = _event; + // @TODO: Should lowercase and whatnot things here instead of copy... + return { type: "orphan", tag: getTag("orphan", event), filter: copy(event) }; + } + + if (((_event).address || (_event).topics)) { + const event = _event; + + const filter: any = { + topics: ((event.topics || []).map((t) => { + if (t == null) { return null; } + if (Array.isArray(t)) { + return concisify(t.map((t) => t.toLowerCase())); + } + return t.toLowerCase(); + })) + }; + + if (event.address) { + const addresses: Array = [ ]; + const promises: Array> = [ ]; + + const addAddress = (addr: AddressLike) => { + if (isHexString(addr)) { + addresses.push(addr); + } else { + promises.push((async () => { + addresses.push(await resolveAddress(addr, provider)); + })()); + } + } + + + if (Array.isArray(event.address)) { + event.address.forEach(addAddress); + } else { + addAddress(event.address); + } + if (promises.length) { await Promise.all(promises); } + filter.address = concisify(addresses.map((a) => a.toLowerCase())); + } + + return { filter, tag: getTag("event", filter), type: "event" }; + } + + return logger.throwArgumentError("unknown ProviderEvent", "event", _event); +} + +function getTime(): number { return (new Date()).getTime(); } + +export interface ProviderPlugin { + readonly name: string; + validate(provider: Provider): ProviderPlugin; +} + +export type PerformActionFilter = { + address?: string | Array; + topics?: Array>; + fromBlock?: BlockTag; + toBlock?: BlockTag; +} | { + address?: string | Array; + topics?: Array>; + blockHash?: string; +}; + +export type PerformActionTransaction = { + type?: number; + + to?: string; + from?: string; + + nonce?: number; + + gasLimit?: bigint; + gasPrice?: bigint; + + maxPriorityFeePerGas?: bigint; + maxFeePerGas?: bigint; + + data?: string; + value?: bigint; + chainId?: bigint; + + accessList?: AccessList; +}; + +export type PerformActionRequest = { + method: "call", + transaction: PerformActionTransaction, blockTag: BlockTag +} | { + method: "chainId" +} | { + method: "estimateGas", + transaction: PerformActionTransaction +} | { + method: "getBalance", + address: string, blockTag: BlockTag +} | { + method: "getBlock", + blockTag: BlockTag, includeTransactions: boolean +} | { + method: "getBlock", + blockHash: string, includeTransactions: boolean +} | { + method: "getBlockNumber" +} | { + method: "getCode", + address: string, blockTag: BlockTag +} | { + method: "getGasPrice" +} | { + method: "getLogs", + filter: PerformActionFilter +} | { + method: "getStorageAt", + address: string, position: bigint, blockTag: BlockTag +} | { + method: "getTransaction", + hash: string +} | { + method: "getTransactionCount", + address: string, blockTag: BlockTag +} | { + method: "getTransactionReceipt", + hash: string +} | { + method: "getTransactionResult", + hash: string +} | { + method: "broadcastTransaction", // @TODO: rename to broadcast + signedTransaction: string +}; + +type _PerformAccountRequest = { + method: "getBalance" | "getTransactionCount" | "getCode" +} | { + method: "getStorageAt", position: bigint +} + +export function copyRequest(tx: T): T { + // @TODO: copy the copy from contracts and use it from this + return tx; +} + +type CcipArgs = { + sender: string; + urls: Array; + calldata: string; + selector: string; + extraData: string; + errorArgs: Array +}; + + + +export class AbstractProvider implements Provider { + + #subs: Map; + #plugins: Map; + + // null=unpaused, true=paused+dropWhilePaused, false=paused + #pausedState: null | boolean; + + #networkPromise: null | Promise>; + readonly #anyNetwork: boolean; + + #performCache: Map>; + + #nextTimer: number; + #timers: Map void, time: number }>; + + #disableCcipRead: boolean; + + // @TODO: This should be a () => Promise so network can be + // done when needed; or rely entirely on _detectNetwork? + constructor(_network?: "any" | Networkish) { + if (_network === "any") { + this.#anyNetwork = true; + this.#networkPromise = null; + } else if (_network) { + const network = Network.from(_network); + this.#anyNetwork = false; + this.#networkPromise = Promise.resolve(network); + setTimeout(() => { this.emit("network", network, null); }, 0); + } else { + this.#anyNetwork = false; + this.#networkPromise = null; + } + + this.#performCache = new Map(); + + this.#subs = new Map(); + this.#plugins = new Map(); + this.#pausedState = null; + + this.#nextTimer = 0; + this.#timers = new Map(); + + this.#disableCcipRead = false; + } + + get provider(): this { return this; } + + get plugins(): Array { + return Array.from(this.#plugins.values()); + } + + attachPlugin(plugin: ProviderPlugin): this { + if (this.#plugins.get(plugin.name)) { + throw new Error(`cannot replace existing plugin: ${ plugin.name } `); + } + this.#plugins.set(plugin.name, plugin.validate(this)); + return this; + } + + getPlugin(name: string): null | T { + return (this.#plugins.get(name)) || null; + } + + set disableCcipRead(value: boolean) { this.#disableCcipRead = !!value; } + get disableCcipRead(): boolean { return this.#disableCcipRead; } + + // Shares multiple identical requests made during the same 250ms + async #perform(req: PerformActionRequest): Promise { + // Create a tag + const tag = getTag(req.method, req); + + let perform = this.#performCache.get(tag); + if (!perform) { + perform = this._perform(req); + this.#performCache.set(tag, perform); + + setTimeout(() => { + if (this.#performCache.get(tag) === perform) { + this.#performCache.delete(tag); + } + }, 250); + } + + return await perform; + } + + async ccipReadFetch(tx: PerformActionTransaction, calldata: string, urls: Array): Promise { + if (this.disableCcipRead || urls.length === 0 || tx.to == null) { return null; } + + const sender = tx.to.toLowerCase(); + const data = calldata.toLowerCase(); + + const errorMessages: Array = [ ]; + + for (let i = 0; i < urls.length; i++) { + const url = urls[i]; + + // URL expansion + const href = url.replace("{sender}", sender).replace("{data}", data); + + // If no {data} is present, use POST; otherwise GET + //const json: string | null = (url.indexOf("{data}") >= 0) ? null: JSON.stringify({ data, sender }); + + //const result = await fetchJson({ url: href, errorPassThrough: true }, json, (value, response) => { + // value.status = response.statusCode; + // return value; + //}); + const request = new FetchRequest(href); + if (url.indexOf("{data}") === -1) { + request.body = { data, sender }; + } + + let errorMessage = "unknown error"; + + const resp = await request.send(); + try { + const result = resp.bodyJson; + if (result.data) { return result.data; } + if (result.message) { errorMessage = result.message; } + } catch (error) { } + + // 4xx indicates the result is not present; stop + if (resp.statusCode >= 400 && resp.statusCode < 500) { + return logger.throwError(`response not found during CCIP fetch: ${ errorMessage }`, "OFFCHAIN_FAULT", { + reason: "404_MISSING_RESOURCE", + transaction: tx, info: { url, errorMessage } + }); + } + + // 5xx indicates server issue; try the next url + errorMessages.push(errorMessage); + } + + return logger.throwError(`error encountered during CCIP fetch: ${ errorMessages.map((m) => JSON.stringify(m)).join(", ") }`, "OFFCHAIN_FAULT", { + reason: "500_SERVER_ERROR", + transaction: tx, info: { urls, errorMessages } + }); + } + + _wrapTransaction(tx: TransactionResponse, hash: string, blockNumber: number): TransactionResponse { + return tx; + } + + _detectNetwork(): Promise> { + return logger.throwError("sub-classes must implement this", "UNSUPPORTED_OPERATION", { + operation: "_detectNetwork" + }); + } + + // Sub-classes should override this and handle PerformActionRequest requests, calling + // the super for any unhandled actions. + async _perform(req: PerformActionRequest): Promise { + return logger.throwError(`unsupported method: ${ req.method }`, "UNSUPPORTED_OPERATION", { + operation: req.method, + info: req + }); + } + + // State + async getBlockNumber(): Promise { + return logger.getNumber(await this.#perform({ method: "getBlockNumber" }), "%response"); + } + +// @TODO: Make this string | Promsie so no await needed if sync is possible + _getAddress(address: AddressLike): string | Promise { + return resolveAddress(address, this); + /* + if (typeof(address) === "string") { + if (address.match(/^0x[0-9a-f]+$/i)) { return address; } + const resolved = await this.resolveName(address); + if (resolved == null) { throw new Error("not confiugred @TODO"); } + return resolved; + } + return address.getAddress(); + */ + } + + _getBlockTag(blockTag?: BlockTag): string | Promise { + if (blockTag == null) { return "latest"; } + + switch (blockTag) { + case "earliest": + return "0x0"; + case "latest": case "pending": case "safe": case "finalized": + return blockTag; + } + + if (isHexString(blockTag)) { + if (dataLength(blockTag) === 32) { return blockTag; } + return toQuantity(blockTag); + } + + if (typeof(blockTag) === "number") { + if (blockTag >= 0) { return toQuantity(blockTag); } + return this.getBlockNumber().then((b) => toQuantity(b + blockTag)); + } + + return logger.throwArgumentError("invalid blockTag", "blockTag", blockTag); + } + + async getNetwork(): Promise> { + + // No explicit network was set and this is our first time + if (this.#networkPromise == null) { + + // Detect the current network (shared with all calls) + const detectNetwork = this._detectNetwork().then((network) => { + this.emit("network", network, null); + return network; + }, (error) => { + // Reset the networkPromise on failure, so we will try again + if (this.#networkPromise === detectNetwork) { + this.#networkPromise = null; + } + throw error; + }); + + this.#networkPromise = detectNetwork; + return await detectNetwork; + } + + const networkPromise = this.#networkPromise; + + const [ expected, actual ] = await Promise.all([ + networkPromise, // Possibly an explicit Network + this._detectNetwork() // The actual connected network + ]); + + if (expected.chainId !== actual.chainId) { + if (this.#anyNetwork) { + // The "any" network can change, so notify listeners + this.emit("network", actual, expected); + + // Update the network if something else hasn't already changed it + if (this.#networkPromise === networkPromise) { + this.#networkPromise = Promise.resolve(actual); + } + } else { + // Otherwise, we do not allow changes to the underlying network + logger.throwError(`network changed: ${ expected.chainId } => ${ actual.chainId } `, "NETWORK_ERROR", { + event: "changed" + }); + } + } + + return expected.clone().freeze(); + } + + async getFeeData(): Promise { + const { block, gasPrice } = await resolveProperties({ + block: this.getBlock("latest"), + gasPrice: ((async () => { + try { + const gasPrice = await this.#perform({ method: "getGasPrice" }); + return logger.getBigInt(gasPrice, "%response"); + } catch (error) { } + return null + })()) + }); + + let maxFeePerGas = null, maxPriorityFeePerGas = null; + + if (block && block.baseFeePerGas) { + // We may want to compute this more accurately in the future, + // using the formula "check if the base fee is correct". + // See: https://eips.ethereum.org/EIPS/eip-1559 + maxPriorityFeePerGas = BigInt("1500000000"); + + // Allow a network to override their maximum priority fee per gas + //const priorityFeePlugin = (await this.getNetwork()).getPlugin("org.ethers.plugins.max-priority-fee"); + //if (priorityFeePlugin) { + // maxPriorityFeePerGas = await priorityFeePlugin.getPriorityFee(this); + //} + maxFeePerGas = (block.baseFeePerGas * BN_2) + maxPriorityFeePerGas; + } + + return new FeeData(gasPrice, maxFeePerGas, maxPriorityFeePerGas); + } + + async _getTransaction(_request: CallRequest): Promise { + const network = await this.getNetwork(); + + // Fill in any addresses + const request = Object.assign({}, _request, await resolveProperties({ + to: (_request.to ? resolveAddress(_request.to, this): undefined), + from: (_request.from ? resolveAddress(_request.from, this): undefined), + })); + + return network.formatter.transactionRequest(request); + } + + async estimateGas(_tx: TransactionRequest) { + const transaction = await this._getTransaction(_tx); + return logger.getBigInt(await this.#perform({ + method: "estimateGas", transaction + }), "%response"); + } + + async #call(tx: PerformActionTransaction, blockTag: string, attempt: number): Promise { + if (attempt >= MAX_CCIP_REDIRECTS) { + logger.throwError("CCIP read exceeded maximum redirections", "OFFCHAIN_FAULT", { + reason: "TOO_MANY_REDIRECTS", + transaction: Object.assign({ }, tx, { blockTag, enableCcipRead: true }) + }); + } + + const transaction = copyRequest(tx); + + try { + return hexlify(await this._perform({ method: "call", transaction, blockTag })); + + } catch (error) { + // CCIP Read OffchainLookup + if (!this.disableCcipRead && isCallException(error) && attempt >= 0 && blockTag === "latest" && transaction.to != null && dataSlice(error.data, 0, 4) === "0x556f1830") { + const data = error.data; + + const txSender = await resolveAddress(transaction.to, this); + + // Parse the CCIP Read Arguments + let ccipArgs: CcipArgs; + try { + ccipArgs = parseOffchainLookup(dataSlice(error.data, 4)); + } catch (error: any) { + return logger.throwError(error.message, "OFFCHAIN_FAULT", { + reason: "BAD_DATA", + transaction, info: { data } + }); + } + + // Check the sender of the OffchainLookup matches the transaction + if (ccipArgs.sender.toLowerCase() !== txSender.toLowerCase()) { + return logger.throwError("CCIP Read sender mismatch", "CALL_EXCEPTION", { + data, transaction, + errorSignature: "OffchainLookup(address,string[],bytes,bytes4,bytes)", + errorName: "OffchainLookup", + errorArgs: ccipArgs.errorArgs + }); + } + + const ccipResult = await this.ccipReadFetch(transaction, ccipArgs.calldata, ccipArgs.urls); + if (ccipResult == null) { + return logger.throwError("CCIP Read failed to fetch data", "OFFCHAIN_FAULT", { + reason: "FETCH_FAILED", + transaction, info: { data: error.data, errorArgs: ccipArgs.errorArgs } + }); + } + + return this.#call({ + to: txSender, + data: concat([ + ccipArgs.selector, encodeBytes([ ccipResult, ccipArgs.extraData ]) + ]), + }, blockTag, attempt + 1); + } + + throw error; + } + } + + async call(_tx: CallRequest) { + const [ tx, blockTag ] = await Promise.all([ + this._getTransaction(_tx), this._getBlockTag(_tx.blockTag) + ]); + return this.#call(tx, blockTag, _tx.enableCcipRead ? 0: -1); + } + + // Account + async #getAccountValue(request: _PerformAccountRequest, _address: AddressLike, _blockTag?: BlockTag): Promise { + let address: string | Promise = this._getAddress(_address); + let blockTag: string | Promise = this._getBlockTag(_blockTag); + + if (typeof(address) !== "string" || typeof(blockTag) !== "string") { + [ address, blockTag ] = await Promise.all([ address, blockTag ]); + } + + return await this.#perform(Object.assign(request, { address, blockTag })); + } + + async getBalance(address: AddressLike, blockTag?: BlockTag) { + return logger.getBigInt(await this.#getAccountValue({ method: "getBalance" }, address, blockTag), "%response"); + } + + async getTransactionCount(address: AddressLike, blockTag?: BlockTag) { + return logger.getNumber(await this.#getAccountValue({ method: "getTransactionCount" }, address, blockTag), "%response"); + } + + async getCode(address: AddressLike, blockTag?: BlockTag) { + return hexlify(await this.#getAccountValue({ method: "getCode" }, address, blockTag)); + } + + async getStorageAt(address: AddressLike, _position: BigNumberish, blockTag?: BlockTag) { + const position = logger.getBigInt(_position, "position"); + return hexlify(await this.#getAccountValue({ method: "getStorageAt", position }, address, blockTag)); + } + + // Write + async broadcastTransaction(signedTx: string) { + throw new Error(); + return { }; + } + + async #getBlock(block: BlockTag | string, includeTransactions: boolean): Promise { + if (isHexString(block, 32)) { + return await this.#perform({ + method: "getBlock", blockHash: block, includeTransactions + }); + } + + let blockTag = this._getBlockTag(block); + if (typeof(blockTag) !== "string") { blockTag = await blockTag; } + + return await this.#perform({ + method: "getBlock", blockTag, includeTransactions + }); + } + + // Queries + async getBlock(block: BlockTag | string): Promise> { + const [ network, params ] = await Promise.all([ + this.getNetwork(), this.#getBlock(block, false) + ]); + + if (params == null) { return null; } + + return network.formatter.block(params, this); + } + + async getBlockWithTransactions(block: BlockTag | string): Promise> { + const format = (await this.getNetwork()).formatter; + + const params = this.#getBlock(block, true); + if (params == null) { return null; } + + return format.blockWithTransactions(params, this); + } + + async getTransaction(hash: string): Promise { + const format = (await this.getNetwork()).formatter; + const params = await this.#perform({ method: "getTransaction", hash }); + return format.transactionResponse(params, this); + } + + async getTransactionReceipt(hash: string): Promise { + const format = (await this.getNetwork()).formatter; + + const receipt = await this.#perform({ method: "getTransactionReceipt", hash }); + if (receipt == null) { return null; } + + // Some backends did not backfill the effectiveGasPrice into old transactions + // in the receipt, so we look it up manually and inject it. + if (receipt.gasPrice == null && receipt.effectiveGasPrice == null) { + const tx = await this.#perform({ method: "getTransaction", hash }); + receipt.effectiveGasPrice = tx.gasPrice; + } + + return format.receipt(receipt, this); + } + + async getTransactionResult(hash: string): Promise { + const result = await this.#perform({ method: "getTransactionResult", hash }); + if (result == null) { return null; } + return hexlify(result); + } + + _getFilter(filter: Filter | FilterByBlockHash): PerformActionFilter | Promise { + + // Create a canonical representation of the topics + const topics = (filter.topics || [ ]).map((t) => { + if (t == null) { return null; } + if (Array.isArray(t)) { + return concisify(t.map((t) => t.toLowerCase())); + } + return t.toLowerCase(); + }); + + const blockHash = ("blockHash" in filter) ? filter.blockHash: undefined; + + const resolve = (_address: Array, fromBlock?: string, toBlock?: string) => { + let address: undefined | string | Array = undefined; + switch (_address.length) { + case 0: break; + case 1: + address = _address[0]; + break; + default: + _address.sort(); + address = _address; + } + + if (blockHash) { + if (fromBlock != null || toBlock != null) { + throw new Error("invalid filter"); + } + } + + const filter = { }; + if (address) { filter.address = address; } + if (topics.length) { filter.topics = topics; } + if (fromBlock) { filter.fromBlock = fromBlock; } + if (toBlock) { filter.toBlock = toBlock; } + if (blockHash) { filter.blockHash = blockHash; } + + return filter; + }; + + // Addresses could be async (ENS names or Addressables) + let address: Array> = [ ]; + if (filter.address) { + if (Array.isArray(filter.address)) { + for (const addr of filter.address) { address.push(this._getAddress(addr)); } + } else { + address.push(this._getAddress(filter.address)); + } + } + + let fromBlock: undefined | string | Promise = undefined; + if ("fromBlock" in filter) { fromBlock = this._getBlockTag(filter.fromBlock); } + + let toBlock: undefined | string | Promise = undefined; + if ("toBlock" in filter) { toBlock = this._getBlockTag(filter.toBlock); } + + if (address.filter((a) => (typeof(a) !== "string")).length || + (fromBlock != null && typeof(fromBlock) !== "string") || + (toBlock != null && typeof(toBlock) !== "string")) { + + return Promise.all([ Promise.all(address), fromBlock, toBlock ]).then((result) => { + return resolve(result[0], result[1], result[2]); + }); + } + + return resolve(>address, fromBlock, toBlock); + } + + // Bloom-filter Queries + async getLogs(_filter: Filter | FilterByBlockHash): Promise> { + const { network, filter } = await resolveProperties({ + network: this.getNetwork(), + filter: this._getFilter(_filter) + }); + + return (await this.#perform>({ method: "getLogs", filter })).map((l) => { + return network.formatter.log(l, this); + }); + } + + // ENS + _getProvider(chainId: number): AbstractProvider { + return logger.throwError("provider cannot connect to target network", "UNSUPPORTED_OPERATION", { + operation: "_getProvider()" + }); + } + + async getResolver(name: string): Promise { + return await EnsResolver.fromName(this, name); + } + + async getAvatar(name: string): Promise { + const resolver = await this.getResolver(name); + if (resolver) { return await resolver.getAvatar(); } + return null; + } + + async resolveName(name: string): Promise{ + //if (typeof(name) === "string") { + const resolver = await this.getResolver(name); + if (resolver) { return await resolver.getAddress(); } + /* + } else { + const address = await name.getAddress(); + if (address == null) { + return logger.throwArgumentError("Addressable returned no address", "name", name); + } + return address; + } + */ + return null; + } + + async lookupAddress(address: string): Promise { + throw new Error(); + //return "TODO"; + } + + async waitForTransaction(hash: string, confirms: number = 1, timeout?: number): Promise { + if (confirms === 0) { return this.getTransactionReceipt(hash); } + + return new Promise(async (resolve, reject) => { + let timer: null | NodeJS.Timer = null; + + const listener = (async (blockNumber: number) => { + try { + const receipt = await this.getTransactionReceipt(hash); + if (receipt != null) { + if (blockNumber - receipt.blockNumber + 1 >= confirms) { + resolve(receipt); + this.off("block", listener); + if (timer) { + clearTimeout(timer); + timer = null; + } + return; + } + } + } catch (error) { + console.log("EEE", error); + } + this.once("block", listener); + }); + + if (timeout != null) { + timer = setTimeout(() => { + if (timer == null) { return; } + timer = null; + this.off("block", listener); + reject(logger.makeError("timeout", "TIMEOUT", { reason: "timeout" })); + }, timeout); + } + + listener(await this.getBlockNumber()); + }); + } + + async waitForBlock(blockTag?: BlockTag): Promise> { + throw new Error(); + //return new Block({ }, this); + } + + _clearTimeout(timerId: number): void { + const timer = this.#timers.get(timerId); + if (!timer) { return; } + if (timer.timer) { clearTimeout(timer.timer); } + this.#timers.delete(timerId); + } + + _setTimeout(_func: () => void, timeout: number = 0): number { + const timerId = this.#nextTimer++; + const func = () => { + this.#timers.delete(timerId); + _func(); + }; + + if (this.paused) { + this.#timers.set(timerId, { timer: null, func, time: timeout }); + } else { + const timer = setTimeout(func, timeout); + this.#timers.set(timerId, { timer, func, time: getTime() }); + } + + return timerId; + } + + _forEachSubscriber(func: (s: Subscriber) => void): void { + for (const sub of this.#subs.values()) { + func(sub.subscriber); + } + } + + // Event API; sub-classes should override this; any supported + // event filter will have been munged into an EventFilter + _getSubscriber(sub: Subscription): Subscriber { + switch (sub.type) { + case "debug": + case "network": + return new UnmanagedSubscriber(sub.type); + case "block": + return new PollingBlockSubscriber(this); + case "event": + return new PollingEventSubscriber(this, sub.filter); + case "transaction": + return new PollingTransactionSubscriber(this, sub.hash); + case "orphan": + return new PollingOrphanSubscriber(this, sub.filter); + } + + throw new Error(`unsupported event: ${ sub.type }`); + } + + _recoverSubscriber(oldSub: Subscriber, newSub: Subscriber): void { + for (const sub of this.#subs.values()) { + if (sub.subscriber === oldSub) { + if (sub.started) { sub.subscriber.stop(); } + sub.subscriber = newSub; + if (sub.started) { newSub.start(); } + if (this.#pausedState != null) { newSub.pause(this.#pausedState); } + break; + } + } + } + + async #hasSub(event: ProviderEvent, emitArgs?: Array): Promise { + let sub = await getSubscription(event, this); + // This is a log that is removing an existing log; we actually want + // to emit an orphan event for the removed log + if (sub.type === "event" && emitArgs && emitArgs.length > 0 && emitArgs[0].removed === true) { + sub = await getSubscription({ orphan: "drop-log", log: emitArgs[0] }, this); + } + return this.#subs.get(sub.tag) || null; + } + + async #getSub(event: ProviderEvent): Promise { + const subscription = await getSubscription(event, this); + + // Prevent tampering with our tag in any subclass' _getSubscriber + const tag = subscription.tag; + + let sub = this.#subs.get(tag); + if (!sub) { + const subscriber = this._getSubscriber(subscription); + const addressableMap = new WeakMap(); + const nameMap = new Map(); + sub = { subscriber, tag, addressableMap, nameMap, started: false, listeners: [ ] }; + this.#subs.set(tag, sub); + } + return sub; + } + + async on(event: ProviderEvent, listener: Listener): Promise { + const sub = await this.#getSub(event); + sub.listeners.push({ listener, once: false }); + if (!sub.started) { + sub.subscriber.start(); + sub.started = true; + if (this.#pausedState != null) { sub.subscriber.pause(this.#pausedState); } + } + return this; + } + + async once(event: ProviderEvent, listener: Listener): Promise { + const sub = await this.#getSub(event); + sub.listeners.push({ listener, once: true }); + if (!sub.started) { + sub.subscriber.start(); + sub.started = true; + if (this.#pausedState != null) { sub.subscriber.pause(this.#pausedState); } + } + return this; + } + + async emit(event: ProviderEvent, ...args: Array): Promise { + const sub = await this.#hasSub(event, args); + if (!sub) { return false; }; + + const count = sub.listeners.length; + sub.listeners = sub.listeners.filter(({ listener, once }) => { + const payload = new EventPayload(this, (once ? null: listener), event); + try { + listener.call(this, ...args, payload); + } catch(error) { } + return !once; + }); + + return (count > 0); + } + + async listenerCount(event?: ProviderEvent): Promise { + if (event) { + const sub = await this.#hasSub(event); + if (!sub) { return 0; } + return sub.listeners.length; + } + + let total = 0; + for (const { listeners } of this.#subs.values()) { + total += listeners.length; + } + return total; + } + + async listeners(event?: ProviderEvent): Promise> { + if (event) { + const sub = await this.#hasSub(event); + if (!sub) { return [ ]; } + return sub.listeners.map(({ listener }) => listener); + } + let result: Array = [ ]; + for (const { listeners } of this.#subs.values()) { + result = result.concat(listeners.map(({ listener }) => listener)); + } + return result; + } + + async off(event: ProviderEvent, listener?: Listener): Promise { + const sub = await this.#hasSub(event); + if (!sub) { return this; } + + if (listener) { + const index = sub.listeners.map(({ listener }) => listener).indexOf(listener); + if (index >= 0) { sub.listeners.splice(index, 1); } + } + + if (!listener || sub.listeners.length === 0) { + if (sub.started) { sub.subscriber.stop(); } + this.#subs.delete(sub.tag); + } + + return this; + } + + async removeAllListeners(event?: ProviderEvent): Promise { + if (event) { + const { tag, started, subscriber } = await this.#getSub(event); + if (started) { subscriber.stop(); } + this.#subs.delete(tag); + } else { + for (const [ tag, { started, subscriber } ] of this.#subs) { + if (started) { subscriber.stop(); } + this.#subs.delete(tag); + } + } + return this; + } + + // Alias for "on" + async addListener(event: ProviderEvent, listener: Listener): Promise { + return await this.on(event, listener); + } + + // Alias for "off" + async removeListener(event: ProviderEvent, listener: Listener): Promise { + return this.off(event, listener); + } + + // Sub-classes should override this to shutdown any sockets, etc. + // but MUST call this super.shutdown. + async shutdown(): Promise { + // Stop all listeners + this.removeAllListeners(); + + // Shut down all tiemrs + for (const timerId of this.#timers.keys()) { + this._clearTimeout(timerId); + } + } + + get paused(): boolean { return (this.#pausedState != null); } + set paused(pause: boolean) { + if (!!pause === this.paused) { return; } + + if (this.paused) { + this.resume(); + } else { + this.pause(false); + } + } + + pause(dropWhilePaused?: boolean): void { + if (this.#pausedState != null) { + if (this.#pausedState == !!dropWhilePaused) { return; } + return logger.throwError("cannot change pause type; resume first", "UNSUPPORTED_OPERATION", { + operation: "pause" + }); + } + + this._forEachSubscriber((s) => s.pause(dropWhilePaused)); + this.#pausedState = !!dropWhilePaused; + + for (const timer of this.#timers.values()) { + // Clear the timer + if (timer.timer) { clearTimeout(timer.timer); } + + // Remaining time needed for when we become unpaused + timer.time = getTime() - timer.time; + } + } + + resume(): void { + if (this.#pausedState == null) { return; } + + this._forEachSubscriber((s) => s.resume()); + this.#pausedState = null; + for (const timer of this.#timers.values()) { + // Remaining time when we were paused + let timeout = timer.time; + if (timeout < 0) { timeout = 0; } + + // Start time (in cause paused, so we con compute remaininf time) + timer.time = getTime(); + + // Start the timer + setTimeout(timer.func, timeout); + } + } +} + + +function _parseString(result: string, start: number): null | string { + try { + const bytes = _parseBytes(result, start); + if (bytes) { return toUtf8String(bytes); } + } catch(error) { } + return null; +} + +function _parseBytes(result: string, start: number): null | string { + if (result === "0x") { return null; } + try { + const offset = logger.getNumber(dataSlice(result, start, start + 32)); + const length = logger.getNumber(dataSlice(result, offset, offset + 32)); + + return dataSlice(result, offset + 32, offset + 32 + length); + } catch (error) { } + return null; +} + +function numPad(value: number): Uint8Array { + const result = toArray(value); + if (result.length > 32) { throw new Error("internal; should not happen"); } + + const padded = new Uint8Array(32); + padded.set(result, 32 - result.length); + return padded; +} + +function bytesPad(value: Uint8Array): Uint8Array { + if ((value.length % 32) === 0) { return value; } + + const result = new Uint8Array(Math.ceil(value.length / 32) * 32); + result.set(value); + return result; +} + +const empty = new Uint8Array([ ]); + +// ABI Encodes a series of (bytes, bytes, ...) +function encodeBytes(datas: Array) { + const result: Array = [ ]; + + let byteCount = 0; + + // Add place-holders for pointers as we add items + for (let i = 0; i < datas.length; i++) { + result.push(empty); + byteCount += 32; + } + + for (let i = 0; i < datas.length; i++) { + const data = logger.getBytes(datas[i]); + + // Update the bytes offset + result[i] = numPad(byteCount); + + // The length and padded value of data + result.push(numPad(data.length)); + result.push(bytesPad(data)); + byteCount += 32 + Math.ceil(data.length / 32) * 32; + } + + return concat(result); +} + +const zeros = "0x0000000000000000000000000000000000000000000000000000000000000000" +function parseOffchainLookup(data: string): CcipArgs { + const result: CcipArgs = { + sender: "", urls: [ ], calldata: "", selector: "", extraData: "", errorArgs: [ ] + }; + + if (dataLength(data) < 5 * 32) { + throw new Error("insufficient OffchainLookup data"); + } + + const sender = dataSlice(data, 0, 32); + if (dataSlice(sender, 0, 12) !== dataSlice(zeros, 0, 12)) { + throw new Error("corrupt OffchainLookup sender"); + } + result.sender = dataSlice(sender, 12); + + // Read the URLs from the response + try { + const urls: Array = []; + const urlsOffset = logger.getNumber(dataSlice(data, 32, 64)); + const urlsLength = logger.getNumber(dataSlice(data, urlsOffset, urlsOffset + 32)); + const urlsData = dataSlice(data, urlsOffset + 32); + for (let u = 0; u < urlsLength; u++) { + const url = _parseString(urlsData, u * 32); + if (url == null) { throw new Error("abort"); } + urls.push(url); + } + result.urls = urls; + } catch (error) { + throw new Error("corrupt OffchainLookup urls"); + } + + // Get the CCIP calldata to forward + try { + const calldata = _parseBytes(data, 64); + if (calldata == null) { throw new Error("abort"); } + result.calldata = calldata; + } catch (error) { throw new Error("corrupt OffchainLookup calldata"); } + + // Get the callbackSelector (bytes4) + if (dataSlice(data, 100, 128) !== dataSlice(zeros, 0, 28)) { + throw new Error("corrupt OffchainLookup callbaackSelector"); + } + result.selector = dataSlice(data, 96, 100); + + // Get the extra data to send back to the contract as context + try { + const extraData = _parseBytes(data, 128); + if (extraData == null) { throw new Error("abort"); } + result.extraData = extraData; + } catch (error) { throw new Error("corrupt OffchainLookup extraData"); } + + result.errorArgs = "sender,urls,calldata,selector,extraData".split(/,/).map((k) => (result)[k]) + + + return result; +} diff --git a/src.ts/providers/abstract-signer.ts b/src.ts/providers/abstract-signer.ts new file mode 100644 index 000000000..757cf939d --- /dev/null +++ b/src.ts/providers/abstract-signer.ts @@ -0,0 +1,199 @@ +import { logger } from "../utils/logger.js"; +import { Transaction } from "../transaction/index.js"; +import { defineProperties, resolveProperties } from "../utils/index.js"; + +import type { TypedDataDomain, TypedDataField } from "../hash/index.js"; +import type { TransactionLike } from "../transaction/index.js"; + +import type { + BlockTag, CallRequest, Provider, TransactionRequest, TransactionResponse +} from "./provider.js"; +import type { Signer } from "./signer.js"; + + +export abstract class AbstractSigner

implements Signer { + readonly provider!: P; + + constructor(provider?: P) { + defineProperties(this, { provider: (provider || null) }); + } + + abstract getAddress(): Promise; + abstract connect(provider: null | Provider): Signer; + + #checkProvider(operation: string): Provider { + if (this.provider) { return this.provider; } + return logger.throwError("missing provider", "UNSUPPORTED_OPERATION", { operation }); + } + + async getNonce(blockTag?: BlockTag): Promise { + return this.#checkProvider("getTransactionCount").getTransactionCount(await this.getAddress(), blockTag); + } + + async #populate(op: string, tx: CallRequest | TransactionRequest): Promise> { + const provider = this.#checkProvider(op); + + //let pop: Deferrable = Object.assign({ }, tx); + let pop: any = Object.assign({ }, tx); + + if (pop.to != null) { + pop.to = provider.resolveName(pop.to).then((to) => { + if (to == null) { + return logger.throwArgumentError("transaction to ENS name not configured", "tx.to", pop.to); + } + return to; + }); + } + + if (pop.from != null) { + const from = pop.from; + pop.from = Promise.all([ + this.getAddress(), + this.resolveName(from) + ]).then(([ address, from ]) => { + if (!from || address.toLowerCase() !== from.toLowerCase()) { + return logger.throwArgumentError("transaction from mismatch", "tx.from", from); + } + return address; + }); + } + + return pop; + } + + async populateCall(tx: CallRequest): Promise> { + const pop = await this.#populate("populateCall", tx); + + return pop; + } + + async populateTransaction(tx: TransactionRequest): Promise> { + const pop = await this.#populate("populateTransaction", tx); + + if (pop.nonce == null) { + pop.nonce = await this.getNonce("pending"); + } + + if (pop.gasLimit == null) { + pop.gasLimit = await this.estimateGas(pop); + } + + //@TODO: Copy type logic from AbstractSigner in v5 + + return await resolveProperties(pop); + } + + async estimateGas(tx: CallRequest): Promise { + return this.#checkProvider("estimateGas").estimateGas(await this.populateCall(tx)); + } + + async call(tx: CallRequest): Promise { + return this.#checkProvider("call").call(await this.populateCall(tx)); + } + + async resolveName(name: string): Promise { + const provider = this.#checkProvider("resolveName"); + return await provider.resolveName(name); + } + + async sendTransaction(tx: TransactionRequest): Promise { + const provider = this.#checkProvider("sendTransaction"); + + const txObj = Transaction.from(await this.populateTransaction(tx)); + return await provider.broadcastTransaction(await this.signTransaction(txObj)); + } + + abstract signTransaction(tx: TransactionRequest): Promise; + abstract signMessage(message: string | Uint8Array): Promise; + abstract signTypedData(domain: TypedDataDomain, types: Record>, value: Record): Promise; +} + +export class VoidSigner extends AbstractSigner { + readonly address!: string; + + constructor(address: string, provider?: null | Provider) { + super(provider); + defineProperties(this, { address }); + } + + async getAddress(): Promise { return this.address; } + + connect(provider: null | Provider): VoidSigner { + return new VoidSigner(this.address, provider); + } + + #throwUnsupported(suffix: string, operation: string): never { + return logger.throwError(`VoidSigner cannot sign ${ suffix }`, "UNSUPPORTED_OPERATION", { + operation + }); + } + + async signTransaction(tx: TransactionRequest): Promise { + this.#throwUnsupported("transactions", "signTransaction"); + } + + async signMessage(message: string | Uint8Array): Promise { + this.#throwUnsupported("messages", "signMessage"); + } + + async signTypedData(domain: TypedDataDomain, types: Record>, value: Record): Promise { + this.#throwUnsupported("typed-data", "signTypedData"); + } +} + +export class WrappedSigner extends AbstractSigner { + #signer: Signer; + + constructor(signer: Signer) { + super(signer.provider); + this.#signer = signer; + } + + async getAddress(): Promise { + return await this.#signer.getAddress(); + } + + connect(provider: null | Provider): WrappedSigner { + return new WrappedSigner(this.#signer.connect(provider)); + } + + async getNonce(blockTag?: BlockTag): Promise { + return await this.#signer.getNonce(blockTag); + } + + async populateCall(tx: CallRequest): Promise> { + return await this.#signer.populateCall(tx); + } + + async populateTransaction(tx: TransactionRequest): Promise> { + return await this.#signer.populateTransaction(tx); + } + + async estimateGas(tx: CallRequest): Promise { + return await this.#signer.estimateGas(tx); + } + + async call(tx: CallRequest): Promise { + return await this.#signer.call(tx); + } + + async resolveName(name: string): Promise { + return this.#signer.resolveName(name); + } + + async signTransaction(tx: TransactionRequest): Promise { + return await this.#signer.signTransaction(tx); + } + + async sendTransaction(tx: TransactionRequest): Promise { + return await this.#signer.sendTransaction(tx); + } + + async signMessage(message: string | Uint8Array): Promise { + return await this.#signer.signMessage(message); + } + + async signTypedData(domain: TypedDataDomain, types: Record>, value: Record): Promise { + return await this.#signer.signTypedData(domain, types, value); + } +} diff --git a/src.ts/providers/common-networks.ts b/src.ts/providers/common-networks.ts new file mode 100644 index 000000000..99082fe66 --- /dev/null +++ b/src.ts/providers/common-networks.ts @@ -0,0 +1,102 @@ + +/** + * Exports the same Network as "./network.js" except with common + * networks injected registered. + */ + +import { EnsPlugin, GasCostPlugin } from "./plugins-network.js"; +import { EtherscanPlugin } from "./provider-etherscan.js"; + +import { Network } from "./network.js"; + +type Options = { + ensNetwork?: number; + priorityFee?: number + altNames?: Array; + etherscan?: { url: string, apiKey: string }; +}; + +// See: https://chainlist.org +export function injectCommonNetworks(): void { + + /// Register popular Ethereum networks + function registerEth(name: string, chainId: number, options: Options): void { + const func = function() { + const network = new Network(name, chainId); + + // We use 0 to disable ENS + if (options.ensNetwork != null) { + network.attachPlugin(new EnsPlugin(null, options.ensNetwork)); + } + + if (options.priorityFee) { +// network.attachPlugin(new MaxPriorityFeePlugin(options.priorityFee)); + } + + if (options.etherscan) { + const { url, apiKey } = options.etherscan; + network.attachPlugin(new EtherscanPlugin(url, apiKey)); + } + + network.attachPlugin(new GasCostPlugin()); + + return network; + }; + + // Register the network by name and chain ID + Network.register(name, func); + Network.register(chainId, func); + + if (options.altNames) { + options.altNames.forEach((name) => { + Network.register(name, func); + }); + } + } + + registerEth("homestead", 1, { ensNetwork: 1, altNames: [ "mainnet" ] }); + registerEth("ropsten", 3, { ensNetwork: 3 }); + registerEth("rinkeby", 4, { ensNetwork: 4 }); + registerEth("goerli", 5, { ensNetwork: 5 }); + registerEth("kovan", 42, { ensNetwork: 42 }); + + registerEth("classic", 61, { }); + registerEth("classicKotti", 6, { }); + + registerEth("xdai", 100, { ensNetwork: 1 }); + + // Polygon has a 35 gwei maxPriorityFee requirement + registerEth("matic", 137, { + ensNetwork: 1, +// priorityFee: 35000000000, + etherscan: { + apiKey: "W6T8DJW654GNTQ34EFEYYP3EZD9DD27CT7", + url: "https:/\/api.polygonscan.com/" + } + }); + registerEth("maticMumbai", 80001, { +// priorityFee: 35000000000, + etherscan: { + apiKey: "W6T8DJW654GNTQ34EFEYYP3EZD9DD27CT7", + url: "https:/\/api-testnet.polygonscan.com/" + } + }); + + registerEth("bnb", 56, { + ensNetwork: 1, + etherscan: { + apiKey: "EVTS3CU31AATZV72YQ55TPGXGMVIFUQ9M9", + url: "http:/\/api.bscscan.com" + } + }); + registerEth("bnbt", 97, { + etherscan: { + apiKey: "EVTS3CU31AATZV72YQ55TPGXGMVIFUQ9M9", + url: "http:/\/api-testnet.bscscan.com" + } + }); +} + +injectCommonNetworks(); + +export { Network }; diff --git a/src.ts/providers/community.ts b/src.ts/providers/community.ts new file mode 100644 index 000000000..dddd1a21a --- /dev/null +++ b/src.ts/providers/community.ts @@ -0,0 +1,24 @@ + +export interface CommunityResourcable { + isCommunityResource(): boolean; +} + +// Show the throttle message only once +const shown: Set = new Set(); +export function showThrottleMessage(service: string) { + if (shown.has(service)) { return; } + shown.add(service); + + console.log("========= NOTICE =========") + console.log(`Request-Rate Exceeded for ${ service } (this message will not be repeated)`); + console.log(""); + console.log("The default API keys for each service are provided as a highly-throttled,"); + console.log("community resource for low-traffic projects and early prototyping."); + console.log(""); + console.log("While your application will continue to function, we highly recommended"); + console.log("signing up for your own API keys to improve performance, increase your"); + console.log("request rate/limit and enable other perks, such as metrics and advanced APIs."); + console.log(""); + console.log("For more details: https:/\/docs.ethers.io/api-keys/"); + console.log("=========================="); +} diff --git a/src.ts/providers/contracts.ts b/src.ts/providers/contracts.ts new file mode 100644 index 000000000..312fc80b8 --- /dev/null +++ b/src.ts/providers/contracts.ts @@ -0,0 +1,21 @@ +import type { + CallRequest, Provider, TransactionRequest, TransactionResponse +} from "./provider.js"; + +// The object that will be used to run Contracts. The Signer and Provider +// both adhere to this, but other types of objects may wish to as well. +export interface ContractRunner { + provider: null | Provider; + + // Required to estimate gas; usually a Signer or Provider + estimateGas?: (tx: TransactionRequest) => Promise; + + // Required for pure, view or static calls to contracts; usually a Signer or Provider + call?: (tx: CallRequest) => Promise; + + // Required to support ENS names; usually a Signer or Provider + resolveName?: (name: string) => Promise; + + // Required for mutating calls; usually a Signer + sendTransaction?: (tx: TransactionRequest) => Promise; +} diff --git a/src.ts/providers/default-provider.ts b/src.ts/providers/default-provider.ts new file mode 100644 index 000000000..9673c1306 --- /dev/null +++ b/src.ts/providers/default-provider.ts @@ -0,0 +1,89 @@ + +import { AnkrProvider } from "./provider-ankr.js"; +import { AlchemyProvider } from "./provider-alchemy.js"; +import { CloudflareProvider } from "./provider-cloudflare.js"; +import { EtherscanProvider } from "./provider-etherscan.js"; +import { InfuraProvider } from "./provider-infura.js"; +//import { PocketProvider } from "./provider-pocket.js"; + +import { FallbackProvider } from "./provider-fallback.js"; +import { JsonRpcProvider } from "./provider-jsonrpc.js"; +import { WebSocketProvider } from "./provider-websocket.js"; + +import type { AbstractProvider } from "./abstract-provider.js"; +import type { Networkish } from "./network.js"; +import { WebSocketLike } from "./provider-websocket.js"; + +function isWebSocketLike(value: any): value is WebSocketLike { + return (value && typeof(value.send) === "function" && + typeof(value.close) === "function"); +} + +export function getDefaultProvider(network: string | Networkish | WebSocketLike, options?: any): AbstractProvider { + if (options == null) { options = { }; } + + if (typeof(network) === "string" && network.match(/^https?:/)) { + return new JsonRpcProvider(network); + } + + if (typeof(network) === "string" && network.match(/^wss?:/) || isWebSocketLike(network)) { + return new WebSocketProvider(network); + } + + const providers: Array = [ ]; + + if (options.alchemy !== "-") { + try { + providers.push(new AlchemyProvider(network, options.alchemy)); + } catch (error) { console.log(error); } + } + + if (options.ankr !== "-") { + try { + providers.push(new AnkrProvider(network, options.ankr)); + } catch (error) { console.log(error); } + } + + if (options.cloudflare !== "-") { + try { + providers.push(new CloudflareProvider(network)); + } catch (error) { console.log(error); } + } + + if (options.etherscan !== "-") { + try { + providers.push(new EtherscanProvider(network, options.etherscan)); + } catch (error) { console.log(error); } + } + + if (options.infura !== "-") { + try { + let projectId = options.infura; + let projectSecret: undefined | string = undefined; + if (typeof(projectId) === "object") { + projectSecret = projectId.projectSecret; + projectId = projectId.projectId; + } + providers.push(new InfuraProvider(network, projectId, projectSecret)); + } catch (error) { console.log(error); } + } +/* + if (options.pocket !== "-") { + try { + let appId = options.pocket; + let secretKey: undefined | string = undefined; + let loadBalancer: undefined | boolean = undefined; + if (typeof(appId) === "object") { + loadBalancer = !!appId.loadBalancer; + secretKey = appId.secretKey; + appId = appId.appId; + } + providers.push(new PocketProvider(network, appId, secretKey, loadBalancer)); + } catch (error) { console.log(error); } + } +*/ + if (providers.length === 0) { throw new Error("TODO"); } + if (providers.length === 1) { return providers[0]; } + + return new FallbackProvider(providers); +} diff --git a/src.ts/providers/ens-resolver.ts b/src.ts/providers/ens-resolver.ts new file mode 100644 index 000000000..1c1899fcd --- /dev/null +++ b/src.ts/providers/ens-resolver.ts @@ -0,0 +1,535 @@ +import { ZeroHash } from "../constants/hashes.js"; +import { dnsEncode, namehash } from "../hash/index.js"; +import { + defineProperties, encodeBase58, toArray, toNumber, toUtf8Bytes, toUtf8String +} from "../utils/index.js"; +import { concat, dataSlice, hexlify, zeroPadValue } from "../utils/data.js"; +import { FetchRequest } from "../utils/fetch.js"; +import { logger } from "../utils/logger.js"; + +import type { BigNumberish, BytesLike, EthersError } from "../utils/index.js"; + +import type { AbstractProvider, ProviderPlugin } from "./abstract-provider.js"; +import type { EnsPlugin } from "./plugins-network.js"; +import type { CallRequest, Provider } from "./provider.js"; + +const BN_1 = BigInt(1); + +const Empty = new Uint8Array([ ]); + +function parseBytes(result: string, start: number): null | string { + if (result === "0x") { return null; } + + const offset = toNumber(dataSlice(result, start, start + 32)); + const length = toNumber(dataSlice(result, offset, offset + 32)); + + return dataSlice(result, offset + 32, offset + 32 + length); +} + +function parseString(result: string, start: number): null | string { + try { + const bytes = parseBytes(result, start); + if (bytes != null) { return toUtf8String(bytes); } + } catch(error) { } + return null; +} + +function numPad(value: BigNumberish): Uint8Array { + const result = toArray(value); + if (result.length > 32) { throw new Error("internal; should not happen"); } + + const padded = new Uint8Array(32); + padded.set(result, 32 - result.length); + return padded; +} + +function bytesPad(value: Uint8Array): Uint8Array { + if ((value.length % 32) === 0) { return value; } + + const result = new Uint8Array(Math.ceil(value.length / 32) * 32); + result.set(value); + return result; +} + +// ABI Encodes a series of (bytes, bytes, ...) +function encodeBytes(datas: Array) { + const result: Array = [ ]; + + let byteCount = 0; + + // Add place-holders for pointers as we add items + for (let i = 0; i < datas.length; i++) { + result.push(Empty); + byteCount += 32; + } + + for (let i = 0; i < datas.length; i++) { + const data = logger.getBytes(datas[i]); + + // Update the bytes offset + result[i] = numPad(byteCount); + + // The length and padded value of data + result.push(numPad(data.length)); + result.push(bytesPad(data)); + byteCount += 32 + Math.ceil(data.length / 32) * 32; + } + + return concat(result); +} + +// @TODO: This should use the fetch-data:ipfs gateway +// Trim off the ipfs:// prefix and return the default gateway URL +function getIpfsLink(link: string): string { + if (link.match(/^ipfs:\/\/ipfs\//i)) { + link = link.substring(12); + } else if (link.match(/^ipfs:\/\//i)) { + link = link.substring(7); + } else { + logger.throwArgumentError("unsupported IPFS format", "link", link); + } + + return `https:/\/gateway.ipfs.io/ipfs/${ link }`; +} + +export type AvatarLinkageType = "name" | "avatar" | "!avatar" | "url" | "data" | "ipfs" | + "erc721" | "erc1155" | "!erc721-caip" | "!erc1155-caip" | + "!owner" | "owner" | "!balance" | "balance" | + "metadata-url-base" | "metadata-url-expanded" | "metadata-url" | "!metadata-url" | + "!metadata" | "metadata" | + "!imageUrl" | "imageUrl-ipfs" | "imageUrl" | "!imageUrl-ipfs"; + +export interface AvatarLinkage { + type: AvatarLinkageType; + value: string; +}; + +export interface AvatarResult { + linkage: Array; + url: null | string; +}; + +export abstract class MulticoinProviderPlugin implements ProviderPlugin { + readonly name!: string; + + constructor(name: string) { + defineProperties(this, { name }); + } + + validate(proivder: Provider): ProviderPlugin { + return this; + } + + supportsCoinType(coinType: number): boolean { + return false; + } + + async encodeAddress(coinType: number, address: string): Promise { + throw new Error("unsupported coin"); + } + + async decodeAddress(coinType: number, data: BytesLike): Promise { + throw new Error("unsupported coin"); + } +} + +const BasicMulticoinPluginId = "org.ethers.provider-prugins.basicmulticoin"; + +export class BasicMulticoinProviderPlugin extends MulticoinProviderPlugin { + constructor() { + super(BasicMulticoinPluginId); + } +} + +const matcherIpfs = new RegExp("^(ipfs):/\/(.*)$", "i"); +const matchers = [ + new RegExp("^(https):/\/(.*)$", "i"), + new RegExp("^(data):(.*)$", "i"), + matcherIpfs, + new RegExp("^eip155:[0-9]+/(erc[0-9]+):(.*)$", "i"), +]; + +export class EnsResolver { + provider!: AbstractProvider; + address!: string; + + name!: string; + + // For EIP-2544 names, the ancestor that provided the resolver + #supports2544: null | Promise; + + constructor(provider: AbstractProvider, address: string, name: string) { + defineProperties(this, { provider, address, name }); + this.#supports2544 = null; + } + + async supportsWildcard(): Promise { + if (!this.#supports2544) { + // supportsInterface(bytes4 = selector("resolve(bytes,bytes)")) + this.#supports2544 = this.provider.call({ + to: this.address, + data: "0x01ffc9a79061b92300000000000000000000000000000000000000000000000000000000" + }).then((result) => { + return (logger.getBigInt(result) === BN_1); + }).catch((error) => { + if (error.code === "CALL_EXCEPTION") { return false; } + // Rethrow the error: link is down, etc. Let future attempts retry. + this.#supports2544 = null; + throw error; + }); + } + + return await this.#supports2544; + } + + async _fetch(selector: string, parameters: BytesLike = "0x"): Promise { + + // e.g. keccak256("addr(bytes32,uint256)") + const addrData = concat([ selector, namehash(this.name), parameters ]); + const tx: CallRequest = { + to: this.address, + enableCcipRead: true, + data: addrData + }; + + // Wildcard support; use EIP-2544 to resolve the request + let wrapped = false; + if (await this.supportsWildcard()) { + wrapped = true; + + // selector("resolve(bytes,bytes)") + tx.data = concat([ "0x9061b923", encodeBytes([ dnsEncode(this.name), addrData ]) ]); + } + + try { + let data = await this.provider.call(tx); + if ((logger.getBytes(data).length % 32) === 4) { + return logger.throwError("resolver threw error", "CALL_EXCEPTION", { + transaction: tx, data + }); + } + if (wrapped) { return parseBytes(data, 0); } + return data; + } catch (error: any) { + if ((error as EthersError).code !== "CALL_EXCEPTION") { throw error; } + } + + return null; + } + + async getAddress(coinType: number = 60): Promise { + if (coinType === 60) { + try { + // keccak256("addr(bytes32)") + const result = await this._fetch("0x3b3b57de"); + + // No address + if (result === "0x" || result === ZeroHash) { return null; } + + const network = await this.provider.getNetwork(); + return network.formatter.callAddress(result); + } catch (error: any) { + if ((error as EthersError).code === "CALL_EXCEPTION") { return null; } + throw error; + } + } + + let coinPlugin: null | MulticoinProviderPlugin = null; + for (const plugin of this.provider.plugins) { + if (!(plugin instanceof MulticoinProviderPlugin)) { continue; } + if (plugin.supportsCoinType(coinType)) { + coinPlugin = plugin; + break; + } + } + + if (coinPlugin == null) { return null; } + + // keccak256("addr(bytes32,uint256") + const data = parseBytes((await this._fetch("0xf1cb7e06", numPad(coinType))) || "0x", 0); + + // No address + if (data == null || data === "0x") { return null; } + + // Compute the address + const address = await coinPlugin.encodeAddress(coinType, data); + + if (address != null) { return address; } + + return logger.throwError(`invalid coin data`, "UNSUPPORTED_OPERATION", { + operation: `getAddress(${ coinType })`, + info: { coinType, data } + }); + } + + async getText(key: string): Promise { + // The key encoded as parameter to fetchBytes + let keyBytes = toUtf8Bytes(key); + + // The nodehash consumes the first slot, so the string pointer targets + // offset 64, with the length at offset 64 and data starting at offset 96 + const calldata = logger.getBytes(concat([ numPad(64), numPad(keyBytes.length), keyBytes ])); + + const hexBytes = parseBytes((await this._fetch("0x59d1d43c", bytesPad(calldata))) || "0x", 0); + if (hexBytes == null || hexBytes === "0x") { return null; } + + return toUtf8String(hexBytes); + } + + async getContentHash(): Promise { + // keccak256("contenthash()") + const hexBytes = parseBytes((await this._fetch("0xbc1c58d1")) || "0x", 0); + + // No contenthash + if (hexBytes == null || hexBytes === "0x") { return null; } + + // IPFS (CID: 1, Type: 70=DAG-PB, 72=libp2p-key) + const ipfs = hexBytes.match(/^0x(e3010170|e5010172)(([0-9a-f][0-9a-f])([0-9a-f][0-9a-f])([0-9a-f]*))$/); + if (ipfs) { + const scheme = (ipfs[1] === "e3010170") ? "ipfs": "ipns"; + const length = parseInt(ipfs[4], 16); + if (ipfs[5].length === length * 2) { + return `${ scheme }:/\/${ encodeBase58("0x" + ipfs[2])}`; + } + } + + // Swarm (CID: 1, Type: swarm-manifest; hash/length hard-coded to keccak256/32) + const swarm = hexBytes.match(/^0xe40101fa011b20([0-9a-f]*)$/) + if (swarm && swarm[1].length === 64) { + return `bzz:/\/${ swarm[1] }`; + } + + return logger.throwError(`invalid or unsupported content hash data`, "UNSUPPORTED_OPERATION", { + operation: "getContentHash()", + info: { data: hexBytes } + }); + } + + async getAvatar(): Promise { + return (await this._getAvatar()).url; + } + + async _getAvatar(): Promise { + const linkage: Array = [ { type: "name", value: this.name } ]; + try { + // test data for ricmoo.eth + //const avatar = "eip155:1/erc721:0x265385c7f4132228A0d54EB1A9e7460b91c0cC68/29233"; + const avatar = await this.getText("avatar"); + if (avatar == null) { + linkage.push({ type: "!avatar", value: "" }); + throw new Error("!avatar"); + } + linkage.push({ type: "avatar", value: avatar }); + + for (let i = 0; i < matchers.length; i++) { + const match = avatar.match(matchers[i]); + if (match == null) { continue; } + + const scheme = match[1].toLowerCase(); + + switch (scheme) { + case "https": + case "data": + linkage.push({ type: "url", value: avatar }); + return { linkage, url: avatar }; + case "ipfs": { + const url = getIpfsLink(avatar); + linkage.push({ type: "ipfs", value: avatar }); + linkage.push({ type: "url", value: url }); + return { linkage, url }; + } + + case "erc721": + case "erc1155": { + // Depending on the ERC type, use tokenURI(uint256) or url(uint256) + const selector = (scheme === "erc721") ? "0xc87b56dd": "0x0e89341c"; + linkage.push({ type: scheme, value: avatar }); + + // The owner of this name + const owner = await this.getAddress(); + if (owner == null) { + linkage.push({ type: "!owner", value: "" }); + throw new Error("!owner"); + } + + const comps = (match[2] || "").split("/"); + if (comps.length !== 2) { + linkage.push({ type: `!${ scheme }caip`, value: (match[2] || "") }); + throw new Error("!caip"); + } + + const formatter = (await this.provider.getNetwork()).formatter; + + const addr = formatter.address(comps[0]); + const tokenId = numPad(comps[1]); + + // Check that this account owns the token + if (scheme === "erc721") { + // ownerOf(uint256 tokenId) + const tokenOwner = formatter.callAddress(await this.provider.call({ + to: addr, data: concat([ "0x6352211e", tokenId ]) + })); + if (owner !== tokenOwner) { + linkage.push({ type: "!owner", value: tokenOwner }); + throw new Error("!owner"); + } + linkage.push({ type: "owner", value: tokenOwner }); + + } else if (scheme === "erc1155") { + // balanceOf(address owner, uint256 tokenId) + const balance = logger.getBigInt(await this.provider.call({ + to: addr, data: concat([ "0x00fdd58e", zeroPadValue(owner, 32), tokenId ]) + })); + if (!balance) { + linkage.push({ type: "!balance", value: "0" }); + throw new Error("!balance"); + } + linkage.push({ type: "balance", value: balance.toString() }); + } + + // Call the token contract for the metadata URL + const tx = { + to: comps[0], + data: concat([ selector, tokenId ]) + }; + + let metadataUrl = parseString(await this.provider.call(tx), 0); + if (metadataUrl == null) { + linkage.push({ type: "!metadata-url", value: "" }); + throw new Error("!metadata-url"); + } + + linkage.push({ type: "metadata-url-base", value: metadataUrl }); + + // ERC-1155 allows a generic {id} in the URL + if (scheme === "erc1155") { + metadataUrl = metadataUrl.replace("{id}", hexlify(tokenId).substring(2)); + linkage.push({ type: "metadata-url-expanded", value: metadataUrl }); + } + + // Transform IPFS metadata links + if (metadataUrl.match(/^ipfs:/i)) { + metadataUrl = getIpfsLink(metadataUrl); + } + linkage.push({ type: "metadata-url", value: metadataUrl }); + + // Get the token metadata + let metadata: any = { }; + const response = await (new FetchRequest(metadataUrl)).send(); + response.assertOk(); + + try { + metadata = response.bodyJson; + } catch (error) { + try { + linkage.push({ type: "!metadata", value: response.bodyText }); + } catch (error) { + const bytes = response.body; + if (bytes) { + linkage.push({ type: "!metadata", value: hexlify(bytes) }); + } + throw error; + } + throw error; + } + + if (!metadata) { + linkage.push({ type: "!metadata", value: "" }); + throw new Error("!metadata"); + } + + linkage.push({ type: "metadata", value: JSON.stringify(metadata) }); + + // Pull the image URL out + let imageUrl = metadata.image; + if (typeof(imageUrl) !== "string") { + linkage.push({ type: "!imageUrl", value: "" }); + throw new Error("!imageUrl"); + } + + if (imageUrl.match(/^(https:\/\/|data:)/i)) { + // Allow + } else { + // Transform IPFS link to gateway + const ipfs = imageUrl.match(matcherIpfs); + if (ipfs == null) { + linkage.push({ type: "!imageUrl-ipfs", value: imageUrl }); + throw new Error("!imageUrl-ipfs"); + } + + linkage.push({ type: "imageUrl-ipfs", value: imageUrl }); + imageUrl = getIpfsLink(imageUrl); + } + + linkage.push({ type: "url", value: imageUrl }); + + return { linkage, url: imageUrl }; + } + } + } + } catch (error) { console.log("EE", error); } + + return { linkage, url: null }; + } + + static async #getResolver(provider: Provider, name: string): Promise { + const network = await provider.getNetwork(); + + const ensPlugin = network.getPlugin("org.ethers.network-plugins.ens"); + + // No ENS... + if (!ensPlugin) { + return logger.throwError("network does not support ENS", "UNSUPPORTED_OPERATION", { + operation: "getResolver", info: { network: network.name } + }); + } + + try { + // keccak256("resolver(bytes32)") + const addrData = await provider.call({ + to: ensPlugin.address, + data: concat([ "0x0178b8bf", namehash(name) ]), + enableCcipRead: true + }); + + const addr = network.formatter.callAddress(addrData); + if (addr === dataSlice(ZeroHash, 0, 20)) { return null; } + return addr; + + } catch (error) { + // ENS registry cannot throw errors on resolver(bytes32), + // so probably a link error + throw error; + } + + return null; + } + + static async fromName(provider: AbstractProvider, name: string): Promise { + + let currentName = name; + while (true) { + if (currentName === "" || currentName === ".") { return null; } + + // Optimization since the eth node cannot change and does + // not have a wildcar resolver + if (name !== "eth" && currentName === "eth") { return null; } + + // Check the current node for a resolver + const addr = await EnsResolver.#getResolver(provider, currentName); + + // Found a resolver! + if (addr != null) { + const resolver = new EnsResolver(provider, addr, name); + + // Legacy resolver found, using EIP-2544 so it isn't safe to use + if (currentName !== name && !(await resolver.supportsWildcard())) { return null; } + + return resolver; + } + + // Get the parent node + currentName = currentName.split(".").slice(1).join("."); + } + } +} diff --git a/src.ts/providers/formatter.ts b/src.ts/providers/formatter.ts new file mode 100644 index 000000000..2e536887c --- /dev/null +++ b/src.ts/providers/formatter.ts @@ -0,0 +1,442 @@ +// Belongs to Networks; requires abstract-provider +// provider requires abstract-provider and network + +/** + * Formatter + * + * This is responsibile for converting much of the various + * loose network values into a concrete ethers-ready value. + * + * For example, converting addresses to checksum addresses, + * validating a hash is 32 bytes, and so on. + * + * By sub-classing this class and providing it in a custom + * Network object this allows exotic (non-Ethereum) networks + * to be fairly simple to adapt to ethers. + */ + +import { getAddress, getCreateAddress } from "../address/index.js"; +import { dataLength, dataSlice, isHexString } from "../utils/data.js"; +import { toQuantity } from "../utils/maths.js"; +import { logger } from "../utils/logger.js"; +import { Signature } from "../crypto/signature.js"; +import { accessListify } from "../transaction/index.js"; + +import { Block, Log, TransactionReceipt, TransactionResponse } from "./provider.js"; + +import type { AccessList } from "../transaction/index.js"; + +import type { PerformActionTransaction } from "./abstract-provider.js"; +import type { Filter, Provider } from "./provider.js"; + + +const BN_MAX_UINT256 = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); + +export type FormatFunc = (value: any) => any; + +//export type AccessListSet = { address: string, storageKeys: Array }; +//export type AccessList = Array; + +//export type AccessListish = AccessList | +// Array<[ string, Array ]> | +// Record>; + +function stringify(value: any): string { + if (typeof(value) !== "string") { throw new Error("invalid string"); } + return value; +} + +export class Formatter { + #format: { + address: FormatFunc, + bigNumber: FormatFunc, + blockTag: FormatFunc, + data: FormatFunc, + filter: FormatFunc, + hash: FormatFunc, + number: FormatFunc, + topics: FormatFunc, + transactionRequest: FormatFunc, + transactionResponse: FormatFunc, + uint256: FormatFunc, + }; + + #baseBlock: FormatFunc; + + constructor() { + const address = this.address.bind(this); + const bigNumber = this.bigNumber.bind(this); + const blockTag = this.blockTag.bind(this); + const data = this.data.bind(this); + const hash = this.hash.bind(this); + const number = this.number.bind(this); + const uint256 = this.uint256.bind(this); + + const topics = this.arrayOf(hash); + + this.#format = { + address, + bigNumber, + blockTag, + data, + hash, + number, + uint256, + + topics, + + filter: this.object({ + fromBlock: this.allowNull(blockTag, undefined), + toBlock: this.allowNull(blockTag, undefined), + blockHash: this.allowNull(hash, undefined), + address: this.allowNull(address, undefined), + topics: this.allowNull(topics, undefined) + }), + + transactionRequest: this.object({ + from: this.allowNull(address), + type: this.allowNull(number), + to: this.allowNull(address), + nonce: this.allowNull(number), + gasLimit: this.allowNull(uint256), + gasPrice: this.allowNull(uint256), + maxFeePerGas: this.allowNull(uint256), + maxPriorityFeePerGas: this.allowNull(uint256), + data: this.allowNull(data), + value: this.allowNull(uint256), + }), + + transactionResponse: this.object({ + hash: hash, + index: number, + + type: this.allowNull(number, 0), + + // These can be null for pending blocks + blockHash: this.allowNull(hash), + blockNumber: this.allowNull(number), + + // For Legacy transactions, this comes from the v + chainId: this.allowNull(number), + + from: address, + to: this.address, + + gasLimit: bigNumber, + + gasPrice: this.allowNull(bigNumber), + maxFeePerGas: this.allowNull(bigNumber), + maxPriorityFeePerGas: this.allowNull(bigNumber), + + value: bigNumber, + data: data, + nonce: number, + r: hash, + s: hash, + v: number, + accessList: this.allowNull(this.accessList) + }, { + index: [ "transactionIndex" ] + }), + }; + + this.#baseBlock = this.object({ + number: number, + hash: this.allowNull(hash, null), + timestamp: number, + + parentHash: hash, + + nonce: this.allowNull(stringify, "0x0000000000000000"), + difficulty: bigNumber, + + gasLimit: bigNumber, + gasUsed: bigNumber, + miner: this.allowNull(address, "0x0000000000000000000000000000000000000000"), + extraData: stringify, + + baseFeePerGas: this.allowNull(bigNumber), + }); + + } + + // An address + address(value: any): string { + return getAddress(value); + } + + // An address from a call result; may be zero-padded + callAddress(value: any): string { + if (dataLength(value) !== 32 || dataSlice(value, 0, 12) !== "0x000000000000000000000000") { + logger.throwArgumentError("invalid call address", "value", value); + } + return this.address(dataSlice(value, 12)); + } + + // An address from a transaction (e.g. { from: string, nonce: number }) + contractAddress(value: any): string { + return getCreateAddress({ + from: this.address(value.from), + nonce: logger.getNumber(value.nonce, "value.nonce") + }); + } + + // Block Tag + blockTag(value?: any): string { + if (value == null) { return "latest"; } + + switch (value) { + case "earliest": + return "0x0"; + case "latest": case "pending": case "safe": case "finalized": + return value; + } + + if (typeof(value) === "number" || (isHexString(value) && dataLength(value) < 32)) { + return toQuantity(value); + } + + return logger.throwArgumentError("invalid blockTag", "value", value); + } + + // Block objects + block(value: any, provider?: Provider): Block { + const params = this.#baseBlock(value); + params.transactions = value.transactions.map((t: any) => this.hash(t)); + return new Block(params, provider); + } + blockWithTransactions(value: any, provider?: Provider): Block { + throw new Error(); + } + + // Transactions + transactionRequest(value: any, provider?: Provider): PerformActionTransaction { + return this.#format.transactionRequest(value); + } + + transactionResponse(value: any, provider?: Provider): TransactionResponse { + value = Object.assign({ }, value); + + // @TODO: Use the remap feature + if (value.data == null && value.input != null) { value.data = value.input; } + if (value.gasLimit == null && value.gas) { value.gasLimit = value.gas; } + + value = this.#format.transactionResponse(value); + + const sig = Signature.from({ r: value.r, s: value.s, v: value.v }); + value.signature = sig; + if (value.chainId == null) { value.chainId = sig.legacyChainId; } + + return new TransactionResponse(value, provider); + } + + // Receipts + log(value: any, provider?: Provider): Log { + const log = this.object({ + address: this.address, + blockHash: this.hash, + blockNumber: this.number, + data: this.data, + index: this.number, + removed: this.boolean, + topics: this.topics, + transactionHash: this.hash, + transactionIndex: this.number, + }, { + index: [ "logIndex" ] + })(value); + return new Log(log, provider); + } + + receipt(value: any, provider?: Provider): TransactionReceipt { + const receipt = this.object({ + blockHash: this.hash, + blockNumber: this.number, + contractAddress: this.allowNull(this.address), + cumulativeGasUsed: this.bigNumber, + from: this.address, + gasUsed: this.bigNumber, + logs: this.arrayOf((v: any) => (this.log(v, provider))), + logsBloom: this.data, + root: this.allowNull(this.data), + status: this.allowNull(this.number), + to: this.address, + gasPrice: this.allowNull(this.bigNumber), + hash: this.hash, + index: this.number, + type: this.allowNull(this.number, 0), + }, { + hash: [ "transactionHash" ], + gasPrice: [ "effectiveGasPrice" ], + index: [ "transactionIndex" ] + })(value); + + // RSK incorrectly implemented EIP-658, so we munge things a bit here for it + if (receipt.root != null) { + if (receipt.root.length <= 4) { + // Could be 0x00, 0x0, 0x01 or 0x1 + const value = parseInt(receipt.root); + if (value === 0 || value === 1) { + // Make sure if both are specified, they match + if (receipt.status != null && receipt.status !== value) { + return logger.throwError("alt-root-status/status mismatch", "BAD_DATA", { + value: { root: receipt.root, status: receipt.status } + }); + } + receipt.status = value; + delete receipt.root; + } else { + return logger.throwError("invalid alt-root-status", "BAD_DATA", { + value: receipt.root + }); + } + } else if (!isHexString(receipt.root, 32)) { + // Must be a valid bytes32 + return logger.throwError("invalid receipt root hash", "BAD_DATA", { + value: receipt.root + }); + } + } + + //receipt.byzantium = (receipt.root == null); + + return new TransactionReceipt(receipt, provider); + } + + // Fitlers + topics(value: any): Array { + return this.#format.topics(value); + } + + filter(value: any): Filter { + return this.#format.filter(value); + } + + filterLog(value: any): any { + console.log("ME", value); + return null; + } + + // Converts a serialized transaction to a TransactionResponse + transaction(value: any): TransactionResponse { + throw new Error(); + } + + // Useful utility formatters functions, which if need be use the + // methods within the formatter to ensure internal compatibility + + // Access List; converts an AccessListish to an AccessList + accessList(value: any): AccessList { + return accessListify(value); + } + + // Converts falsish values to a specific value, otherwise use the formatter. Calls preserve `this`. + allowFalsish(format: FormatFunc, ifFalse: any): FormatFunc { + return ((value: any) => { + if (!value) { return ifFalse; } + return format.call(this, value); + }); + } + + // Allows null, optionally replacing it with a default value. Calls preserve `this`. + allowNull(format: FormatFunc, ifNull?: any): FormatFunc { + return ((value: any) => { + if (value == null) { return ifNull; } + return format.call(this, value); + }); + } + + // Requires an Array satisfying the formatter. Calls preserves `this`. + arrayOf(format: FormatFunc): FormatFunc { + return ((array: any) => { + if (!Array.isArray(array)) { throw new Error("not an array"); } + return array.map((i) => format.call(this, i)); + }); + } + + // Requires a value which is a value BigNumber + bigNumber(value: any): bigint { + return logger.getBigInt(value, "value"); + } + + uint256(value: any): bigint { + const result = this.bigNumber(value); + if (result < 0 || result > BN_MAX_UINT256) { + logger.throwArgumentError("invalid uint256", "value", value); + } + return result; + } + + // Requires a value which is a value boolean or string equivalent + boolean(value: any): boolean { + switch (value) { + case true: case "true": + return true; + case false: case "false": + return false; + } + return logger.throwArgumentError(`invalid boolean; ${ JSON.stringify(value) }`, "value", value); + } + + // Requires a value which is a valid hexstring. If dataOrLength is true, + // the length must be even (i.e. a datahexstring) or if it is a number, + // specifies teh number of bytes value must represent + _hexstring(dataOrLength?: boolean | number): FormatFunc { + if (dataOrLength == null) { dataOrLength = false; } + return (function(value: any) { + if (isHexString(value, dataOrLength)) { + return value.toLowerCase(); + } + throw new Error("bad hexstring"); + }); + } + + data(value: string): string { + if (dataLength(value) == null) { + logger.throwArgumentError("", "value", value); + } + return value; + } + + // Requires a network-native hash + hash(value: any): string { + if (dataLength(value) !== 32) { + logger.throwArgumentError("", "value", value); + } + return this.#format.data(value); + } + + // Requires a valid number, within the IEEE 754 safe range + number(value: any): number { + return logger.getNumber(value); + } + + // Requires an object which matches a fleet of other formatters + // Any FormatFunc may return `undefined` to have the value omitted + // from the result object. Calls preserve `this`. + object(format: Record, altNames?: Record>): FormatFunc { + return ((value: any) => { + const result: any = { }; + for (const key in format) { + let srcKey = key; + if (altNames && key in altNames && !(srcKey in value)) { + for (const altKey of altNames[key]) { + if (altKey in value) { + srcKey = altKey; + break; + } + } + } + + try { + const nv = format[key].call(this, value[srcKey]); + if (nv !== undefined) { result[key] = nv; } + } catch (error) { + const message = (error instanceof Error) ? error.message: "not-an-error"; + logger.throwError(`invalid value for value.${ key } (${ message })`, "BAD_DATA", { value }) + } + } + return result; + }); + } +} diff --git a/src.ts/providers/index.ts b/src.ts/providers/index.ts new file mode 100644 index 000000000..5fe28b49b --- /dev/null +++ b/src.ts/providers/index.ts @@ -0,0 +1,92 @@ +/* +export { + AbstractProvider, UnmanagedSubscriber +} from "./abstract-provider.js"; +*/ + +export { + AbstractSigner, + VoidSigner, + WrappedSigner +} from "./abstract-signer.js"; +/* +export { + showThrottleMessage +} from "./community.js"; + +export { getDefaultProvider } from "./default-provider.js"; + +export { EnsResolver } from "./ens-resolver.js"; +*/ + +export { Formatter } from "./formatter.js"; + +export { Network } from "./common-networks.js"; + +export { + NetworkPlugin, + GasCostPlugin, + EnsPlugin, + //LayerOneConnectionPlugin, + //MaxPriorityFeePlugin, + //PriceOraclePlugin, +} from "./plugins-network.js"; + +export { + Block, + FeeData, + Log, + TransactionReceipt, + TransactionResponse, + + dummyProvider, + + copyRequest, + //resolveTransactionRequest, +} from "./provider.js"; + +export { FallbackProvider } from "./provider-fallback.js"; +export { JsonRpcApiProvider, JsonRpcProvider, JsonRpcSigner } from "./provider-jsonrpc.js" + +export { AlchemyProvider } from "./provider-alchemy.js"; +export { AnkrProvider } from "./provider-ankr.js"; +export { CloudflareProvider } from "./provider-cloudflare.js"; +export { EtherscanProvider } from "./provider-etherscan.js"; +export { InfuraProvider } from "./provider-infura.js"; +//export { PocketProvider } from "./provider-pocket.js"; + +import { IpcSocketProvider } from "./provider-ipcsocket.js"; /*-browser*/ +export { IpcSocketProvider }; +export { SocketProvider } from "./provider-socket.js"; +export { WebSocketProvider } from "./provider-websocket.js"; + + +/* +export type { + ProviderPlugin, Subscriber, Subscription +} from "./abstract-provider.js" +*/ +export type { ContractRunner } from "./contracts.js"; +/* +export type { + CommunityResourcable +} from "./community.js"; + +export type { + AvatarLinkageType, AvatarLinkage, AvatarResult +} from "./ens-resolver.js"; +*/ +export type { FormatFunc } from "./formatter.js"; + +export type { Networkish } from "./network.js"; + +export type { GasCostParameters } from "./plugins-network.js"; + +export type { + BlockTag, + CallRequest, TransactionRequest, PreparedRequest, + EventFilter, Filter, FilterByBlockHash, OrphanFilter, ProviderEvent, TopicFilter, + Provider, +} from "./provider.js"; + +export type { Signer } from "./signer.js"; diff --git a/src.ts/providers/network.ts b/src.ts/providers/network.ts new file mode 100644 index 000000000..0075faabe --- /dev/null +++ b/src.ts/providers/network.ts @@ -0,0 +1,236 @@ +import { logger } from "../utils/logger.js"; +import { getStore, setStore } from "../utils/storage.js"; + +import { Formatter } from "./formatter.js"; +import { EnsPlugin, GasCostPlugin } from "./plugins-network.js"; + +import type { BigNumberish } from "../utils/index.js"; +import type { Freezable, Frozen } from "../utils/index.js"; +import type { TransactionLike } from "../transaction/index.js"; + +import type { NetworkPlugin } from "./plugins-network.js"; + +/** + * A Networkish can be used to allude to a Network, by specifing: + * - a [[Network]] object + * - a well-known (or registered) network name + * - a well-known (or registered) chain ID + * - an object with sufficient details to describe a network + */ +export type Networkish = Network | number | bigint | string | { + name?: string, + chainId?: number, + //layerOneConnection?: Provider, + ensAddress?: string, + ensNetwork?: number +}; + + + + +/* * * * +// Networks which operation against an L2 can use this plugin to +// specify how to access L1, for the purpose of resolving ENS, +// for example. +export class LayerOneConnectionPlugin extends NetworkPlugin { + readonly provider!: Provider; +// @TODO: Rename to ChainAccess and allow for connecting to any chain + constructor(provider: Provider) { + super("org.ethers.plugins.layer-one-connection"); + defineProperties(this, { provider }); + } + + clone(): LayerOneConnectionPlugin { + return new LayerOneConnectionPlugin(this.provider); + } +} +*/ + +/* * * * +export class PriceOraclePlugin extends NetworkPlugin { + readonly address!: string; + + constructor(address: string) { + super("org.ethers.plugins.price-oracle"); + defineProperties(this, { address }); + } + + clone(): PriceOraclePlugin { + return new PriceOraclePlugin(this.address); + } +} +*/ + +// Networks or clients with a higher need for security (such as clients +// that may automatically make CCIP requests without user interaction) +// can use this plugin to anonymize requests or intercept CCIP requests +// to notify and/or receive authorization from the user +/* * * * +export type FetchDataFunc = (req: Frozen) => Promise; +export class CcipPreflightPlugin extends NetworkPlugin { + readonly fetchData!: FetchDataFunc; + + constructor(fetchData: FetchDataFunc) { + super("org.ethers.plugins.ccip-preflight"); + defineProperties(this, { fetchData }); + } + + clone(): CcipPreflightPlugin { + return new CcipPreflightPlugin(this.fetchData); + } +} +*/ + +const Networks: Map Network> = new Map(); + +const defaultFormatter = new Formatter(); + +export class Network implements Freezable { + #props: { + name: string, + chainId: bigint, + + formatter: Formatter, + + plugins: Map + }; + + constructor(name: string, _chainId: BigNumberish, formatter?: Formatter) { + const chainId = logger.getBigInt(_chainId); + if (formatter == null) { formatter = defaultFormatter; } + const plugins = new Map(); + this.#props = { name, chainId, formatter, plugins }; + } + + toJSON(): any { + return { name: this.name, chainId: this.chainId }; + } + + get name(): string { return getStore(this.#props, "name"); } + set name(value: string) { setStore(this.#props, "name", value); } + + get chainId(): bigint { return getStore(this.#props, "chainId"); } + set chainId(value: BigNumberish) { setStore(this.#props, "chainId", logger.getBigInt(value, "chainId")); } + + get formatter(): Formatter { return getStore(this.#props, "formatter"); } + set formatter(value: Formatter) { setStore(this.#props, "formatter", value); } + + get plugins(): Array { + return Array.from(this.#props.plugins.values()); + } + + attachPlugin(plugin: NetworkPlugin): this { + if (this.isFrozen()) { throw new Error("frozen"); } + if (this.#props.plugins.get(plugin.name)) { + throw new Error(`cannot replace existing plugin: ${ plugin.name } `); + } + this.#props.plugins.set(plugin.name, plugin.validate(this)); + return this; + } + + getPlugin(name: string): null | T { + return (this.#props.plugins.get(name)) || null; + } + + // Gets a list of Plugins which match basename, ignoring any fragment + getPlugins(basename: string): Array { + return >(this.plugins.filter((p) => (p.name.split("#")[0] === basename))); + } + + clone(): Network { + const clone = new Network(this.name, this.chainId, this.formatter); + this.plugins.forEach((plugin) => { + clone.attachPlugin(plugin.clone()); + }); + return clone; + } + + freeze(): Frozen { + Object.freeze(this.#props); + return this; + } + + isFrozen(): boolean { + return Object.isFrozen(this.#props); + } + + computeIntrinsicGas(tx: TransactionLike): number { + const costs = this.getPlugin("org.ethers.gas-cost") || (new GasCostPlugin()); + + let gas = costs.txBase; + if (tx.to == null) { gas += costs.txCreate; } + if (tx.data) { + for (let i = 2; i < tx.data.length; i += 2) { + if (tx.data.substring(i, i + 2) === "00") { + gas += costs.txDataZero; + } else { + gas += costs.txDataNonzero; + } + } + } + + if (tx.accessList) { + const accessList = this.formatter.accessList(tx.accessList); + for (const addr in accessList) { + gas += costs.txAccessListAddress + costs.txAccessListStorageKey * accessList[addr].storageKeys.length; + } + } + + return gas; + } + + static from(network?: Networkish): Network { + // Default network + if (network == null) { return Network.from("homestead"); } + + // Canonical name or chain ID + if (typeof(network) === "number") { network = BigInt(network); } + if (typeof(network) === "string" || typeof(network) === "bigint") { + const networkFunc = Networks.get(network); + if (networkFunc) { return networkFunc(); } + if (typeof(network) === "bigint") { + return new Network("unknown", network); + } + + logger.throwArgumentError("unknown network", "network", network); + } + + // Clonable with network-like abilities + if (typeof((network).clone) === "function") { + const clone = (network).clone(); + //if (typeof(network.name) !== "string" || typeof(network.chainId) !== "number") { + //} + return clone; + } + + // Networkish + if (typeof(network) === "object") { + if (typeof(network.name) !== "string" || typeof(network.chainId) !== "number") { + logger.throwArgumentError("invalid network object name or chainId", "network", network); + } + + const custom = new Network((network.name), (network.chainId)); + + if ((network).ensAddress || (network).ensNetwork != null) { + custom.attachPlugin(new EnsPlugin((network).ensAddress, (network).ensNetwork)); + } + + //if ((network).layerOneConnection) { + // custom.attachPlugin(new LayerOneConnectionPlugin((network).layerOneConnection)); + //} + + return custom; + } + + return logger.throwArgumentError("invalid network", "network", network); + } + + static register(nameOrChainId: string | number | bigint, networkFunc: () => Network): void { + if (typeof(nameOrChainId) === "number") { nameOrChainId = BigInt(nameOrChainId); } + const existing = Networks.get(nameOrChainId); + if (existing) { + logger.throwArgumentError(`conflicting network for ${ JSON.stringify(existing.name) }`, "nameOrChainId", nameOrChainId); + } + Networks.set(nameOrChainId, networkFunc); + } +} diff --git a/src.ts/providers/pagination.ts b/src.ts/providers/pagination.ts new file mode 100644 index 000000000..022688c03 --- /dev/null +++ b/src.ts/providers/pagination.ts @@ -0,0 +1,8 @@ +export interface PaginationResult extends Array { + next(): Promise>; + + // The total number of results available or null if unknown + totalResults: null | number; + + done: boolean; +} diff --git a/src.ts/providers/plugins-network.ts b/src.ts/providers/plugins-network.ts new file mode 100644 index 000000000..493058796 --- /dev/null +++ b/src.ts/providers/plugins-network.ts @@ -0,0 +1,143 @@ +import { defineProperties } from "../utils/properties.js"; + +import { logger } from "../utils/logger.js"; + +//import { BigNumberish } from "../math/index.js"; + +import type { Network } from "./network.js"; +import type { FeeData, Provider } from "./provider.js"; + + +const EnsAddress = "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"; + +export class NetworkPlugin { + readonly name!: string; + + constructor(name: string) { + defineProperties(this, { name }); + } + + clone(): NetworkPlugin { + return new NetworkPlugin(this.name); + } + + validate(network: Network): NetworkPlugin { + return this; + } +} + +// Networks can use this plugin to override calculations for the +// intrinsic gas cost of a transaction for networks that differ +// from the latest hardfork on Ethereum mainnet. +export type GasCostParameters = { + txBase?: number; + txCreate?: number; + txDataZero?: number; + txDataNonzero?: number; + txAccessListStorageKey?: number; + txAccessListAddress?: number; +}; + +export class GasCostPlugin extends NetworkPlugin { + readonly effectiveBlock!: number; + + readonly txBase!: number; + readonly txCreate!: number; + readonly txDataZero!: number; + readonly txDataNonzero!: number; + readonly txAccessListStorageKey!: number; + readonly txAccessListAddress!: number; + + constructor(effectiveBlock: number = 0, costs?: GasCostParameters) { + super(`org.ethers.network-plugins.gas-cost#${ (effectiveBlock || 0) }`); + + const props: Record = { effectiveBlock }; + function set(name: keyof GasCostParameters, nullish: number): void { + let value = (costs || { })[name]; + if (value == null) { value = nullish; } + if (typeof(value) !== "number") { + logger.throwArgumentError(`invalud value for ${ name }`, "costs", costs); + } + props[name] = value; + } + + set("txBase", 21000); + set("txCreate", 32000); + set("txDataZero", 4); + set("txDataNonzero", 16); + set("txAccessListStorageKey", 1900); + set("txAccessListAddress", 2400); + + defineProperties(this, props); + } + + clone(): GasCostPlugin { + return new GasCostPlugin(this.effectiveBlock, this); + } +} + +// Networks shoudl use this plugin to specify the contract address +// and network necessary to resolve ENS names. +export class EnsPlugin extends NetworkPlugin { + + // The ENS contract address + readonly address!: string; + + // The network ID that the ENS contract lives on + readonly targetNetwork!: number; + + constructor(address?: null | string, targetNetwork?: null | number) { + super("org.ethers.network-plugins.ens"); + defineProperties(this, { + address: (address || EnsAddress), + targetNetwork: ((targetNetwork == null) ? 1: targetNetwork) + }); + } + + clone(): EnsPlugin { + return new EnsPlugin(this.address, this.targetNetwork); + } + + validate(network: Network): this { + network.formatter.address(this.address); + return this; + } +} +/* +export class MaxPriorityFeePlugin extends NetworkPlugin { + readonly priorityFee!: bigint; + + constructor(priorityFee: BigNumberish) { + super("org.ethers.plugins.max-priority-fee"); + defineProperties(this, { + priorityFee: logger.getBigInt(priorityFee) + }); + } + + async getPriorityFee(provider: Provider): Promise { + return this.priorityFee; + } + + clone(): MaxPriorityFeePlugin { + return new MaxPriorityFeePlugin(this.priorityFee); + } +} +*/ +export class FeeDataNetworkPlugin extends NetworkPlugin { + readonly #feeDataFunc: (provider: Provider) => Promise; + + get feeDataFunc(): (provider: Provider) => Promise { return this.#feeDataFunc; } + + constructor(feeDataFunc: (provider: Provider) => Promise) { + super("org.ethers.network-plugins.fee-data"); + this.#feeDataFunc = feeDataFunc; + } + + async getFeeData(provider: Provider): Promise { + return await this.#feeDataFunc(provider); + } + + clone(): FeeDataNetworkPlugin { + return new FeeDataNetworkPlugin(this.#feeDataFunc); + } +} diff --git a/src.ts/providers/provider-alchemy.ts b/src.ts/providers/provider-alchemy.ts new file mode 100644 index 000000000..c10b2cefe --- /dev/null +++ b/src.ts/providers/provider-alchemy.ts @@ -0,0 +1,114 @@ + +import { defineProperties } from "../utils/properties.js"; +import { FetchRequest } from "../utils/fetch.js"; + +import { showThrottleMessage } from "./community.js"; +import { logger } from "../utils/logger.js"; +import { Network } from "./network.js"; +import { JsonRpcProvider } from "./provider-jsonrpc.js"; + +import type { AbstractProvider, PerformActionRequest } from "./abstract-provider.js"; +import type { CommunityResourcable } from "./community.js"; +import type { Networkish } from "./network.js"; + + +const defaultApiKey = "_gg7wSSi0KMBsdKnGVfHDueq6xMB9EkC" + +function getHost(name: string): string { + switch(name) { + case "homestead": + return "eth-mainnet.alchemyapi.io"; + case "ropsten": + return "eth-ropsten.alchemyapi.io"; + case "rinkeby": + return "eth-rinkeby.alchemyapi.io"; + case "goerli": + return "eth-goerli.alchemyapi.io"; + case "kovan": + return "eth-kovan.alchemyapi.io"; + case "matic": + return "polygon-mainnet.g.alchemy.com"; + case "maticmum": + return "polygon-mumbai.g.alchemy.com"; + case "arbitrum": + return "arb-mainnet.g.alchemy.com"; + case "arbitrum-rinkeby": + return "arb-rinkeby.g.alchemy.com"; + case "optimism": + return "opt-mainnet.g.alchemy.com"; + case "optimism-kovan": + return "opt-kovan.g.alchemy.com"; + } + + return logger.throwArgumentError("unsupported network", "network", name); +} + +export class AlchemyProvider extends JsonRpcProvider implements CommunityResourcable { + readonly apiKey!: string; + + constructor(_network: Networkish = "homestead", apiKey?: null | string) { + const network = Network.from(_network); + if (apiKey == null) { apiKey = defaultApiKey; } + + const request = AlchemyProvider.getRequest(network, apiKey); + super(request, network, { staticNetwork: network }); + + defineProperties(this, { apiKey }); + } + + _getProvider(chainId: number): AbstractProvider { + try { + return new AlchemyProvider(chainId, this.apiKey); + } catch (error) { } + return super._getProvider(chainId); + } + + async _perform(req: PerformActionRequest): Promise { + + // https://docs.alchemy.com/reference/trace-transaction + if (req.method === "getTransactionResult") { + const trace = await this.send("trace_transaction", [ req.hash ]); + if (trace == null) { return null; } + + let data: undefined | string; + let error = false; + try { + data = trace[0].result.output; + error = (trace[0].error === "Reverted"); + } catch (error) { } + + if (data) { + if (error) { + logger.throwError("an error occurred during transaction executions", "CALL_EXCEPTION", { + data + }); + } + return data; + } + + return logger.throwError("could not parse trace result", "BAD_DATA", { value: trace }); + } + + return await super._perform(req); + } + + isCommunityResource(): boolean { + return (this.apiKey === defaultApiKey); + } + + static getRequest(network: Network, apiKey?: string): FetchRequest { + if (apiKey == null) { apiKey = defaultApiKey; } + + const request = new FetchRequest(`https:/\/${ getHost(network.name) }/v2/${ apiKey }`); + request.allowGzip = true; + + if (apiKey === defaultApiKey) { + request.retryFunc = async (request, response, attempt) => { + showThrottleMessage("alchemy"); + return true; + } + } + + return request; + } +} diff --git a/src.ts/providers/provider-ankr.ts b/src.ts/providers/provider-ankr.ts new file mode 100644 index 000000000..b51db0ac9 --- /dev/null +++ b/src.ts/providers/provider-ankr.ts @@ -0,0 +1,77 @@ +import { defineProperties } from "../utils/properties.js"; +import { FetchRequest } from "../utils/fetch.js"; + +import { AbstractProvider } from "./abstract-provider.js"; +import { showThrottleMessage } from "./community.js"; +import { logger } from "../utils/logger.js"; +import { Network } from "./network.js"; +import { JsonRpcProvider } from "./provider-jsonrpc.js"; + +import type { CommunityResourcable } from "./community.js"; +import type { Networkish } from "./network.js"; + + +const defaultApiKey = "9f7d929b018cdffb338517efa06f58359e86ff1ffd350bc889738523659e7972"; + +function getHost(name: string): string { + switch (name) { + case "homestead": + return "rpc.ankr.com/eth"; + case "ropsten": + return "rpc.ankr.com/eth_ropsten"; + case "rinkeby": + return "rpc.ankr.com/eth_rinkeby"; + case "goerli": + return "rpc.ankr.com/eth_goerli"; + case "matic": + return "rpc.ankr.com/polygon"; + case "arbitrum": + return "rpc.ankr.com/arbitrum"; + } + return logger.throwArgumentError("unsupported network", "network", name); +} + + +export class AnkrProvider extends JsonRpcProvider implements CommunityResourcable { + readonly apiKey!: string; + + constructor(_network: Networkish = "homestead", apiKey?: null | string) { + const network = Network.from(_network); + if (apiKey == null) { apiKey = defaultApiKey; } + + // Ankr does not support filterId, so we force polling + const options = { polling: true, staticNetwork: network }; + + const request = AnkrProvider.getRequest(network, apiKey); + super(request, network, options); + + defineProperties(this, { apiKey }); + } + + _getProvider(chainId: number): AbstractProvider { + try { + return new AnkrProvider(chainId, this.apiKey); + } catch (error) { } + return super._getProvider(chainId); + } + + static getRequest(network: Network, apiKey?: null | string): FetchRequest { + if (apiKey == null) { apiKey = defaultApiKey; } + + const request = new FetchRequest(`https:/\/${ getHost(network.name) }/${ apiKey }`); + request.allowGzip = true; + + if (apiKey === defaultApiKey) { + request.retryFunc = async (request, response, attempt) => { + showThrottleMessage("AnkrProvider"); + return true; + }; + } + + return request; + } + + isCommunityResource(): boolean { + return (this.apiKey === defaultApiKey); + } +} diff --git a/src.ts/providers/provider-cloudflare.ts b/src.ts/providers/provider-cloudflare.ts new file mode 100644 index 000000000..efdb008a5 --- /dev/null +++ b/src.ts/providers/provider-cloudflare.ts @@ -0,0 +1,17 @@ + +import { logger } from "../utils/logger.js"; +import { Network } from "./network.js"; +import { JsonRpcProvider } from "./provider-jsonrpc.js"; + +import type { Networkish } from "./network.js"; + + +export class CloudflareProvider extends JsonRpcProvider { + constructor(_network: Networkish = "homestead") { + const network = Network.from(_network); + if (network.name !== "homestead") { + return logger.throwArgumentError("unsupported network", "network", _network); + } + super("https:/\/cloudflare-eth.com/", network, { staticNetwork: network }); + } +} diff --git a/src.ts/providers/provider-etherscan.ts b/src.ts/providers/provider-etherscan.ts new file mode 100644 index 000000000..32ece799f --- /dev/null +++ b/src.ts/providers/provider-etherscan.ts @@ -0,0 +1,508 @@ +import { hexlify, isHexString } from "../utils/data.js"; +import { toQuantity } from "../utils/maths.js"; +import { isError } from "../utils/errors.js"; +import { defineProperties } from "../utils/properties.js"; +import { toUtf8String } from "../utils/utf8.js"; +import { FetchRequest } from "../utils/fetch.js"; + +if (false) { console.log(isHexString, isError); } // @TODO + +import { AbstractProvider } from "./abstract-provider.js"; +import { Network } from "./network.js"; +import { NetworkPlugin } from "./plugins-network.js"; + + +import { PerformActionRequest } from "./abstract-provider.js"; +import type { Networkish } from "./network.js"; +//import type { } from "./pagination"; +import type { TransactionRequest } from "./provider.js"; + +import { logger } from "../utils/logger.js"; + + +const defaultApiKey = "9D13ZE7XSBTJ94N9BNJ2MA33VMAY2YPIRB"; + + + +const EtherscanPluginId = "org.ethers.plugins.etherscan"; +export class EtherscanPlugin extends NetworkPlugin { + readonly baseUrl!: string; + readonly communityApiKey!: string; + + constructor(baseUrl: string, communityApiKey: string) { + super(EtherscanPluginId); + //if (communityApiKey == null) { communityApiKey = null; } + defineProperties(this, { baseUrl, communityApiKey }); + } + + clone(): EtherscanPlugin { + return new EtherscanPlugin(this.baseUrl, this.communityApiKey); + } +} + + +export class EtherscanProvider extends AbstractProvider { + readonly network!: Network; + readonly apiKey!: string; + + constructor(_network?: Networkish, apiKey?: string) { + super(); + + const network = Network.from(_network); + if (apiKey == null) { + const plugin = network.getPlugin(EtherscanPluginId); + if (plugin) { + apiKey = plugin.communityApiKey; + } else { + apiKey = defaultApiKey; + } + } + + defineProperties(this, { apiKey, network }); + + // Test that the network is supported by Etherscan + this.getBaseUrl(); + } + + getBaseUrl(): string { + const plugin = this.network.getPlugin(EtherscanPluginId); + if (plugin) { return plugin.baseUrl; } + + switch(this.network.name) { + case "homestead": + return "https:/\/api.etherscan.io"; + case "ropsten": + return "https:/\/api-ropsten.etherscan.io"; + case "rinkeby": + return "https:/\/api-rinkeby.etherscan.io"; + case "kovan": + return "https:/\/api-kovan.etherscan.io"; + case "goerli": + return "https:/\/api-goerli.etherscan.io"; + default: + } + + return logger.throwArgumentError("unsupported network", "network", this.network); + } + + getUrl(module: string, params: Record): string { + const query = Object.keys(params).reduce((accum, key) => { + const value = params[key]; + if (value != null) { + accum += `&${ key }=${ value }` + } + return accum + }, ""); + const apiKey = ((this.apiKey) ? `&apikey=${ this.apiKey }`: ""); + return `${ this.getBaseUrl() }/api?module=${ module }${ query }${ apiKey }`; + } + + getPostUrl(): string { + return `${ this.getBaseUrl() }/api`; + } + + getPostData(module: string, params: Record): Record { + params.module = module; + params.apikey = this.apiKey; + return params; + } + + async detectNetwork(): Promise { + return this.network; + } + + async fetch(module: string, params: Record, post?: boolean): Promise { + const url = (post ? this.getPostUrl(): this.getUrl(module, params)); + const payload = (post ? this.getPostData(module, params): null); + + /* + this.emit("debug", { + action: "request", + request: url, + provider: this + }); + */ + const request = new FetchRequest(url); + request.processFunc = async (request, response) => { + const result = response.hasBody() ? JSON.parse(toUtf8String(response.body)): { }; + const throttle = ((typeof(result.result) === "string") ? result.result: "").toLowerCase().indexOf("rate limit") >= 0; + if (module === "proxy") { + // This JSON response indicates we are being throttled + if (result && result.status == 0 && result.message == "NOTOK" && throttle) { + response.throwThrottleError(result.result); + } + } else { + if (throttle) { + response.throwThrottleError(result.result); + } + } + return response; + }; + // @TODO: + //throttleSlotInterval: 1000, + + if (payload) { + request.setHeader("content-type", "application/x-www-form-urlencoded; charset=UTF-8"); + request.body = Object.keys(payload).map((k) => `${ k }=${ payload[k] }`).join("&"); + } + + const response = await request.send(); + response.assertOk(); + + if (!response.hasBody()) { + throw new Error(); + } + + /* + this.emit("debug", { + action: "response", + request: url, + response: deepCopy(result), + provider: this + }); + */ + + const result = JSON.parse(toUtf8String(response.body)); + + if (module === "proxy") { + if (result.jsonrpc != "2.0") { + // @TODO: not any + const error: any = new Error("invalid response"); + error.result = JSON.stringify(result); + throw error; + } + + if (result.error) { + // @TODO: not any + const error: any = new Error(result.error.message || "unknown error"); + if (result.error.code) { error.code = result.error.code; } + if (result.error.data) { error.data = result.error.data; } + throw error; + } + + return result.result; + + } else { + // getLogs, getHistory have weird success responses + if (result.status == 0 && (result.message === "No records found" || result.message === "No transactions found")) { + return result.result; + } + + if (result.status != 1 || result.message != "OK") { + const error: any = new Error("invalid response"); + error.result = JSON.stringify(result); + // if ((result.result || "").toLowerCase().indexOf("rate limit") >= 0) { + // error.throttleRetry = true; + // } + throw error; + } + + return result.result; + } + } + + // The transaction has already been sanitized by the calls in Provider + _getTransactionPostData(transaction: TransactionRequest): Record { + const result: Record = { }; + for (let key in transaction) { + if ((transaction)[key] == null) { continue; } + let value = (transaction)[key]; + if (key === "type" && value === 0) { continue; } + + // Quantity-types require no leading zero, unless 0 + if (({ type: true, gasLimit: true, gasPrice: true, maxFeePerGs: true, maxPriorityFeePerGas: true, nonce: true, value: true })[key]) { + value = toQuantity(hexlify(value)); + } else if (key === "accessList") { + value = "[" + this.network.formatter.accessList(value).map((set) => { + return `{address:"${ set.address }",storageKeys:["${ set.storageKeys.join('","') }"]}`; + }).join(",") + "]"; + } else { + value = hexlify(value); + } + result[key] = value; + } + return result; + } + + + _checkError(req: PerformActionRequest, error: Error, transaction: any): never { + /* + let body = ""; + if (isError(error, Logger.Errors.SERVER_ERROR) && error.response && error.response.hasBody()) { + body = toUtf8String(error.response.body); + } + console.log(body); + + // Undo the "convenience" some nodes are attempting to prevent backwards + // incompatibility; maybe for v6 consider forwarding reverts as errors + if (method === "call" && body) { + + // Etherscan keeps changing their string + if (body.match(/reverted/i) || body.match(/VM execution error/i)) { + + // Etherscan prefixes the data like "Reverted 0x1234" + let data = e.data; + if (data) { data = "0x" + data.replace(/^.*0x/i, ""); } + if (!isHexString(data)) { data = "0x"; } + + logger.throwError("call exception", Logger.Errors.CALL_EXCEPTION, { + error, data + }); + } + } + + // Get the message from any nested error structure + let message = error.message; + if (isError(error, Logger.Errors.SERVER_ERROR)) { + if (error.error && typeof(error.error.message) === "string") { + message = error.error.message; + } else if (typeof(error.body) === "string") { + message = error.body; + } else if (typeof(error.responseText) === "string") { + message = error.responseText; + } + } + message = (message || "").toLowerCase(); + + // "Insufficient funds. The account you tried to send transaction from + // does not have enough funds. Required 21464000000000 and got: 0" + if (message.match(/insufficient funds/)) { + logger.throwError("insufficient funds for intrinsic transaction cost", Logger.Errors.INSUFFICIENT_FUNDS, { + error, transaction, info: { method } + }); + } + + // "Transaction with the same hash was already imported." + if (message.match(/same hash was already imported|transaction nonce is too low|nonce too low/)) { + logger.throwError("nonce has already been used", Logger.Errors.NONCE_EXPIRED, { + error, transaction, info: { method } + }); + } + + // "Transaction gas price is too low. There is another transaction with + // same nonce in the queue. Try increasing the gas price or incrementing the nonce." + if (message.match(/another transaction with same nonce/)) { + logger.throwError("replacement fee too low", Logger.Errors.REPLACEMENT_UNDERPRICED, { + error, transaction, info: { method } + }); + } + + if (message.match(/execution failed due to an exception|execution reverted/)) { + logger.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.Errors.UNPREDICTABLE_GAS_LIMIT, { + error, transaction, info: { method } + }); + } +*/ + throw error; + } + + async _detectNetwork(): Promise { + return this.network; + } + + async _perform(req: PerformActionRequest): Promise { + switch (req.method) { + case "chainId": + return this.network.chainId; + + case "getBlockNumber": + return this.fetch("proxy", { action: "eth_blockNumber" }); + + case "getGasPrice": + return this.fetch("proxy", { action: "eth_gasPrice" }); + + case "getBalance": + // Returns base-10 result + return this.fetch("account", { + action: "balance", + address: req.address, + tag: req.blockTag + }); + + case "getTransactionCount": + return this.fetch("proxy", { + action: "eth_getTransactionCount", + address: req.address, + tag: req.blockTag + }); + + case "getCode": + return this.fetch("proxy", { + action: "eth_getCode", + address: req.address, + tag: req.blockTag + }); + + case "getStorageAt": + return this.fetch("proxy", { + action: "eth_getStorageAt", + address: req.address, + position: req.position, + tag: req.blockTag + }); + + case "broadcastTransaction": + return this.fetch("proxy", { + action: "eth_sendRawTransaction", + hex: req.signedTransaction + }, true).catch((error) => { + return this._checkError(req, error, req.signedTransaction); + }); + + case "getBlock": + if ("blockTag" in req) { + return this.fetch("proxy", { + action: "eth_getBlockByNumber", + tag: req.blockTag, + boolean: (req.includeTransactions ? "true": "false") + }); + } + + return logger.throwError("getBlock by blockHash not supported by Etherscan", "UNSUPPORTED_OPERATION", { + operation: "getBlock(blockHash)" + }); + + case "getTransaction": + return this.fetch("proxy", { + action: "eth_getTransactionByHash", + txhash: req.hash + }); + + case "getTransactionReceipt": + return this.fetch("proxy", { + action: "eth_getTransactionReceipt", + txhash: req.hash + }); + + case "call": { + if (req.blockTag !== "latest") { + throw new Error("EtherscanProvider does not support blockTag for call"); + } + + const postData = this._getTransactionPostData(req.transaction); + postData.module = "proxy"; + postData.action = "eth_call"; + + try { + return await this.fetch("proxy", postData, true); + } catch (error) { + return this._checkError(req, error, req.transaction); + } + } + + case "estimateGas": { + const postData = this._getTransactionPostData(req.transaction); + postData.module = "proxy"; + postData.action = "eth_estimateGas"; + + try { + return await this.fetch("proxy", postData, true); + } catch (error) { + return this._checkError(req, error, req.transaction); + } + } +/* + case "getLogs": { + // Needs to complain if more than one address is passed in + const args: Record = { action: "getLogs" } + + if (params.filter.fromBlock) { + args.fromBlock = checkLogTag(params.filter.fromBlock); + } + + if (params.filter.toBlock) { + args.toBlock = checkLogTag(params.filter.toBlock); + } + + if (params.filter.address) { + args.address = params.filter.address; + } + + // @TODO: We can handle slightly more complicated logs using the logs API + if (params.filter.topics && params.filter.topics.length > 0) { + if (params.filter.topics.length > 1) { + logger.throwError("unsupported topic count", Logger.Errors.UNSUPPORTED_OPERATION, { topics: params.filter.topics }); + } + if (params.filter.topics.length === 1) { + const topic0 = params.filter.topics[0]; + if (typeof(topic0) !== "string" || topic0.length !== 66) { + logger.throwError("unsupported topic format", Logger.Errors.UNSUPPORTED_OPERATION, { topic0: topic0 }); + } + args.topic0 = topic0; + } + } + + const logs: Array = await this.fetch("logs", args); + + // Cache txHash => blockHash + let blocks: { [tag: string]: string } = {}; + + // Add any missing blockHash to the logs + for (let i = 0; i < logs.length; i++) { + const log = logs[i]; + if (log.blockHash != null) { continue; } + if (blocks[log.blockNumber] == null) { + const block = await this.getBlock(log.blockNumber); + if (block) { + blocks[log.blockNumber] = block.hash; + } + } + + log.blockHash = blocks[log.blockNumber]; + } + + return logs; + } +*/ + default: + break; + } + + return super._perform(req); + } + + async getNetwork(): Promise { + return this.network; + } + + async getEtherPrice(): Promise { + if (this.network.name !== "homestead") { return 0.0; } + return parseFloat((await this.fetch("stats", { action: "ethprice" })).ethusd); + } + + isCommunityResource(): boolean { + const plugin = this.network.getPlugin(EtherscanPluginId); + if (plugin) { return (plugin.communityApiKey === this.apiKey); } + + return (defaultApiKey === this.apiKey); + } +} +/* +(async function() { + const provider = new EtherscanProvider(); + console.log(provider); + console.log(await provider.getBlockNumber()); + / * + provider.on("block", (b) => { + console.log("BB", b); + }); + console.log(await provider.getTransactionReceipt("0xa5ded92f548e9f362192f9ab7e5b3fbc9b5a919a868e29247f177d49ce38de6e")); + + provider.once("0xa5ded92f548e9f362192f9ab7e5b3fbc9b5a919a868e29247f177d49ce38de6e", (tx) => { + console.log("TT", tx); + }); + * / + try { + console.log(await provider.getBlock(100)); + } catch (error) { + console.log(error); + } + + try { + console.log(await provider.getBlock(13821768)); + } catch (error) { + console.log(error); + } + +})(); +*/ diff --git a/src.ts/providers/provider-fallback.ts b/src.ts/providers/provider-fallback.ts new file mode 100644 index 000000000..c2ca31e64 --- /dev/null +++ b/src.ts/providers/provider-fallback.ts @@ -0,0 +1,555 @@ + +import { hexlify } from "../utils/data.js"; + +import { AbstractProvider } from "./abstract-provider.js"; +import { logger } from "../utils/logger.js"; +import { Network } from "./network.js" + +import type { Frozen } from "../utils/index.js"; + +import type { PerformActionRequest } from "./abstract-provider.js"; +import type { Networkish } from "./network.js" + +//const BN_0 = BigInt("0"); +const BN_1 = BigInt("1"); +const BN_2 = BigInt("2"); + +function shuffle(array: Array): void { + for (let i = array.length - 1; i > 0; i--) { + const j = Math.floor(Math.random() * (i + 1)); + const tmp = array[i]; + array[i] = array[j]; + array[j] = tmp; + } +} + +function stall(duration: number) { + return new Promise((resolve) => { setTimeout(resolve, duration); }); +} + +function getTime(): number { return (new Date()).getTime(); } + +export interface FallbackProviderConfig { + + // The provider + provider: AbstractProvider; + + // How long to wait for a response before getting impatient + // and ispatching the next provider + stallTimeout?: number; + + // Lower values are dispatched first + priority?: number; + + // How much this provider contributes to the quorum + weight?: number; +}; + +const defaultConfig = { stallTimeout: 400, priority: 1, weight: 1 }; + +// We track a bunch of extra stuff that might help debug problems or +// optimize infrastructure later on. +export interface FallbackProviderState extends Required { + + // The most recent blockNumber this provider has reported (-2 if none) + blockNumber: number; + + // The number of total requests ever sent to this provider + requests: number; + + // The number of responses that errored + errorResponses: number; + + // The number of responses that occured after the result resolved + lateResponses: number; + + // How many times syncing was required to catch up the expected block + outOfSync: number; + + // The number of requests which reported unsupported operation + unsupportedEvents: number; + + // A rolling average (5% current duration) for response time + rollingDuration: number; + + // The ratio of quorum-agreed results to total + score: number; +} + +interface Config extends FallbackProviderState { + _updateNumber: null | Promise; + _network: null | Frozen; + _totalTime: number; +} + +const defaultState = { + blockNumber: -2, requests: 0, lateResponses: 0, errorResponses: 0, + outOfSync: -1, unsupportedEvents: 0, rollingDuration: 0, score: 0, + _network: null, _updateNumber: null, _totalTime: 0 +}; + + +async function waitForSync(config: Config, blockNumber: number): Promise { + while (config.blockNumber < 0 || config.blockNumber < blockNumber) { + if (!config._updateNumber) { + config._updateNumber = (async () => { + const blockNumber = await config.provider.getBlockNumber(); + if (blockNumber > config.blockNumber) { + config.blockNumber = blockNumber; + } + config._updateNumber = null; + })(); + } + await config._updateNumber; + config.outOfSync++; + } +} + +export type FallbackProviderOptions = { + // How many providers must agree on a value before reporting + // back the response + quorum: number; + + // How many providers must have reported the same event + // for it to be emitted + eventQuorum: number; + + // How many providers to dispatch each event to simultaneously. + // Set this to 0 to use getLog polling, which implies eventQuorum + // is equal to quorum. + eventWorkers: number; +}; + +type RunningState = { + config: Config; + staller: null | Promise; + didBump: boolean; + perform: null | Promise; + done: boolean; + result: { result: any } | { error: Error } +} + +// Normalizes a result to a string that can be used to compare against +// other results using normal string equality +function normalize(network: Frozen, value: any, req: PerformActionRequest): string { + switch (req.method) { + case "chainId": + return logger.getBigInt(value).toString(); + case "getBlockNumber": + return logger.getNumber(value).toString(); + case "getGasPrice": + return logger.getBigInt(value).toString(); + case "getBalance": + return logger.getBigInt(value).toString(); + case "getTransactionCount": + return logger.getNumber(value).toString(); + case "getCode": + return hexlify(value); + case "getStorageAt": + return hexlify(value); + case "getBlock": + if (req.includeTransactions) { + return JSON.stringify(network.formatter.blockWithTransactions(value)); + } + return JSON.stringify(network.formatter.block(value)); + case "getTransaction": + return JSON.stringify(network.formatter.transactionResponse(value)); + case "getTransactionReceipt": + return JSON.stringify(network.formatter.receipt(value)); + case "call": + return hexlify(value); + case "estimateGas": + return logger.getBigInt(value).toString(); + case "getLogs": + return JSON.stringify(value.map((v: any) => network.formatter.log(v))); + } + + return logger.throwError("unsupported method", "UNSUPPORTED_OPERATION", { + operation: `_perform(${ JSON.stringify(req.method) })` + }); +} + +type TallyResult = { + result: any; + normal: string; + weight: number; +}; + +// This strategy picks the highest wieght result, as long as the weight is +// equal to or greater than quorum +function checkQuorum(quorum: number, results: Array): any { + const tally: Map = new Map(); + for (const { result, normal, weight } of results) { + const t = tally.get(normal) || { result, weight: 0 }; + t.weight += weight; + tally.set(normal, t); + } + + let bestWeight = 0; + let bestResult = undefined; + + for (const { weight, result } of tally.values()) { + if (weight >= quorum && weight > bestWeight) { + bestWeight = weight; + bestResult = result; + } + } + + return bestResult; +} + +/* +function getMean(results: Array): bigint { + const total = results.reduce((a, r) => (a + BigInt(r.result)), BN_0); + return total / BigInt(results.length); +} +*/ + +function getMedian(results: Array): bigint { + // Get the sorted values + const values = results.map((r) => BigInt(r.result)); + values.sort((a, b) => ((a < b) ? -1: (b > a) ? 1: 0)); + + const mid = values.length / 2; + + // Odd-length; take the middle value + if (values.length % 2) { return values[mid]; } + + // Even length; take the ceiling of the mean of the center two values + return (values[mid - 1] + values[mid] + BN_1) / BN_2; +} + +function getFuzzyMode(quorum: number, results: Array): undefined | number { + if (quorum === 1) { return logger.getNumber(getMedian(results), "%internal"); } + + const tally: Map = new Map(); + const add = (result: number, weight: number) => { + const t = tally.get(result) || { result, weight: 0 }; + t.weight += weight; + tally.set(result, t); + }; + + for (const { weight, result } of results) { + const r = logger.getNumber(result); + add(r - 1, weight); + add(r, weight); + add(r + 1, weight); + } + + let bestWeight = 0; + let bestResult = undefined; + + for (const { weight, result } of tally.values()) { + // Use this result, if this result meets quorum and has either: + // - a better weight + // - or equal weight, but the result is larger + if (weight >= quorum && (weight > bestWeight || (bestResult != null && weight === bestWeight && result > bestResult))) { + bestWeight = weight; + bestResult = result; + } + } + + return bestResult; +} + +export class FallbackProvider extends AbstractProvider { + //readonly providerConfigs!: ReadonlyArray>>; + + readonly quorum: number; + readonly eventQuorum: number; + readonly eventWorkers: number; + + readonly #configs: Array; + + #height: number; + #initialSyncPromise: null | Promise; + + constructor(providers: Array, network?: Networkish) { + super(network); + this.#configs = providers.map((p) => { + if (p instanceof AbstractProvider) { + return Object.assign({ provider: p }, defaultConfig, defaultState ); + } else { + return Object.assign({ }, defaultConfig, p, defaultState ); + } + }); + + this.#height = -2; + this.#initialSyncPromise = null; + + this.quorum = 2; //Math.ceil(providers.length / 2); + this.eventQuorum = 1; + this.eventWorkers = 1; + + if (this.quorum > this.#configs.reduce((a, c) => (a + c.weight), 0)) { + logger.throwArgumentError("quorum exceed provider wieght", "quorum", this.quorum); + } + } + + // @TOOD: Copy these and only return public values + get providerConfigs(): Array { + return this.#configs.slice(); + } + + async _detectNetwork() { + return Network.from(logger.getBigInt(await this._perform({ method: "chainId" }))).freeze(); + } + + // @TODO: Add support to select providers to be the event subscriber + //_getSubscriber(sub: Subscription): Subscriber { + // throw new Error("@TODO"); + //} + + // Grab the next (random) config that is not already part of configs + #getNextConfig(configs: Array): null | Config { + // Shuffle the states, sorted by priority + const allConfigs = this.#configs.slice(); + shuffle(allConfigs); + allConfigs.sort((a, b) => (b.priority - a.priority)); + + for (const config of allConfigs) { + if (configs.indexOf(config) === -1) { return config; } + } + + return null; + } + + // Adds a new runner (if available) to running. + #addRunner(running: Set, req: PerformActionRequest): null | RunningState { + const config = this.#getNextConfig(Array.from(running).map((r) => r.config)); + if (config == null) { + return null; + } + + const result: any = { }; + + const runner: RunningState = { + config, result, didBump: false, done: false, + perform: null, staller: null + }; + + const now = getTime(); + + runner.perform = (async () => { + try { + config.requests++; + result.result = await config.provider._perform(req); + } catch (error) { + config.errorResponses++; + result.error = error; + } + + if (runner.done) { config.lateResponses++; } + + const dt = (getTime() - now); + config._totalTime += dt; + + config.rollingDuration = 0.95 * config.rollingDuration + 0.05 * dt; + + runner.perform = null; + })(); + + runner.staller = (async () => { + await stall(config.stallTimeout); + runner.staller = null; + })(); + + running.add(runner); + return runner; + } + + // Initializes the blockNumber and network for each runner and + // blocks until initialized + async #initialSync(): Promise { + let initialSync = this.#initialSyncPromise; + if (!initialSync) { + const promises: Array> = [ ]; + this.#configs.forEach((config) => { + promises.push(waitForSync(config, 0)); + promises.push((async () => { + config._network = await config.provider.getNetwork(); + })()); + }); + + this.#initialSyncPromise = initialSync = (async () => { + // Wait for all providers to have a block number and network + await Promise.all(promises); + + // Check all the networks match + let chainId: null | bigint = null; + for (const config of this.#configs) { + const network = >(config._network); + if (chainId == null) { + chainId = network.chainId; + } else if (network.chainId !== chainId) { + logger.throwError("cannot mix providers on different networks", "UNSUPPORTED_OPERATION", { + operation: "new FallbackProvider" + }); + } + } + })(); + } + + await initialSync + } + + + async #checkQuorum(running: Set, req: PerformActionRequest): Promise { + // Get all the result objects + const results: Array = [ ]; + for (const runner of running) { + if ("result" in runner.result) { + const result = runner.result.result; + results.push({ + result, + normal: normalize(>(runner.config._network), result, req), + weight: runner.config.weight + }); + } + } + + // Are there enough results to event meet quorum? + if (results.reduce((a, r) => (a + r.weight), 0) < this.quorum) { + return undefined; + } + + switch (req.method) { + case "getBlockNumber": { + // We need to get the bootstrap block height + if (this.#height === -2) { + const height = Math.ceil(logger.getNumber(getMedian(this.#configs.map((c) => ({ + result: c.blockNumber, + normal: logger.getNumber(c.blockNumber).toString(), + weight: c.weight + }))), "%internal")); + this.#height = height; + } + + const mode = getFuzzyMode(this.quorum, results); + if (mode === undefined) { return undefined; } + if (mode > this.#height) { this.#height = mode; } + return this.#height; + } + + case "getGasPrice": + case "estimateGas": + return getMedian(results); + + case "getBlock": + // Pending blocks are mempool dependant and already + // quite untrustworthy + if ("blockTag" in req && req.blockTag === "pending") { + return results[0].result; + } + return checkQuorum(this.quorum, results); + + case "chainId": + case "getBalance": + case "getTransactionCount": + case "getCode": + case "getStorageAt": + case "getTransaction": + case "getTransactionReceipt": + case "getLogs": + return checkQuorum(this.quorum, results); + + case "call": + // @TODO: Check errors + return checkQuorum(this.quorum, results); + + case "broadcastTransaction": + throw new Error("TODO"); + } + + return logger.throwError("unsupported method", "UNSUPPORTED_OPERATION", { + operation: `_perform(${ JSON.stringify((req).method) })` + }); + } + + async #waitForQuorum(running: Set, req: PerformActionRequest): Promise { + if (running.size === 0) { throw new Error("no runners?!"); } + + // Any promises that are interesting to watch for; an expired stall + // or a successful perform + const interesting: Array> = [ ]; + + //const results: Array = [ ]; + //const errors: Array = [ ]; + let newRunners = 0; + for (const runner of running) { +// @TODO: use runner.perfom != null + /* + if ("result" in runner.result) { + results.push(runner.result.result); + } else if ("error" in runner.result) { + errors.push(runner.result.error); + } +*/ + // No responses, yet; keep an eye on it + if (runner.perform) { + interesting.push(runner.perform); + } + + // Still stalling... + if (runner.staller) { + interesting.push(runner.staller); + continue; + } + + // This runner has already triggered another runner + if (runner.didBump) { continue; } + + // Got a response (result or error) or stalled; kick off another runner + runner.didBump = true; + newRunners++; + } + + // Check for quorum + /* + console.log({ results, errors } ); + if (results.length >= this.quorum) { + return results[0]; + } + + if (errors.length >= this.quorum) { + return errors[0]; + } + */ + const value = await this.#checkQuorum(running, req); + if (value !== undefined) { + if (value instanceof Error) { throw value; } + return value; + } + + // Add any new runners, because a staller timed out or a result + // or error response came in. + for (let i = 0; i < newRunners; i++) { + this.#addRunner(running, req) + } + + if (interesting.length === 0) { + throw new Error("quorum not met"); +// return logger.throwError("failed to meet quorum", "", { +// }); + } + + // Wait for someone to either complete its perform or trigger a stall + await Promise.race(interesting); + + return await this.#waitForQuorum(running, req); + } + + async _perform(req: PerformActionRequest): Promise { + await this.#initialSync(); + + // Bootstrap enough to meet quorum + const running: Set = new Set(); + for (let i = 0; i < this.quorum; i++) { + this.#addRunner(running, req); + } + + const result = this.#waitForQuorum(running, req); + for (const runner of running) { runner.done = true; } + return result; + } +} diff --git a/src.ts/providers/provider-infura.ts b/src.ts/providers/provider-infura.ts new file mode 100644 index 000000000..6c787e156 --- /dev/null +++ b/src.ts/providers/provider-infura.ts @@ -0,0 +1,89 @@ +import { defineProperties } from "../utils/properties.js"; +import { FetchRequest } from "../utils/fetch.js"; + +import { showThrottleMessage } from "./community.js"; +import { logger } from "../utils/logger.js"; +import { Network } from "./network.js"; +import { JsonRpcProvider } from "./provider-jsonrpc.js"; + +import type { AbstractProvider } from "./abstract-provider.js"; +import type { CommunityResourcable } from "./community.js"; +import type { Networkish } from "./network.js"; + + +const defaultProjectId = "84842078b09946638c03157f83405213"; + +function getHost(name: string): string { + switch(name) { + case "homestead": + return "mainnet.infura.io"; + case "ropsten": + return "ropsten.infura.io"; + case "rinkeby": + return "rinkeby.infura.io"; + case "kovan": + return "kovan.infura.io"; + case "goerli": + return "goerli.infura.io"; + case "matic": + return "polygon-mainnet.infura.io"; + case "maticmum": + return "polygon-mumbai.infura.io"; + case "optimism": + return "optimism-mainnet.infura.io"; + case "optimism-kovan": + return "optimism-kovan.infura.io"; + case "arbitrum": + return "arbitrum-mainnet.infura.io"; + case "arbitrum-rinkeby": + return "arbitrum-rinkeby.infura.io"; + } + + return logger.throwArgumentError("unsupported network", "network", name); +} + + +export class InfuraProvider extends JsonRpcProvider implements CommunityResourcable { + readonly projectId!: string; + readonly projectSecret!: null | string; + + constructor(_network: Networkish = "homestead", projectId?: null | string, projectSecret?: null | string) { + const network = Network.from(_network); + if (projectId == null) { projectId = defaultProjectId; } + if (projectSecret == null) { projectSecret = null; } + + const request = InfuraProvider.getRequest(network, projectId, projectSecret); + super(request, network, { staticNetwork: network }); + + defineProperties(this, { projectId, projectSecret }); + } + + _getProvider(chainId: number): AbstractProvider { + try { + return new InfuraProvider(chainId, this.projectId, this.projectSecret); + } catch (error) { } + return super._getProvider(chainId); + } + + static getRequest(network: Network, projectId?: null | string, projectSecret?: null | string): FetchRequest { + if (projectId == null) { projectId = defaultProjectId; } + if (projectSecret == null) { projectSecret = null; } + + const request = new FetchRequest(`https:/\/${ getHost(network.name) }/v3/${ projectId }`); + request.allowGzip = true; + if (projectSecret) { request.setCredentials("", projectSecret); } + + if (projectId === defaultProjectId) { + request.retryFunc = async (request, response, attempt) => { + showThrottleMessage("InfuraProvider"); + return true; + }; + } + + return request; + } + + isCommunityResource(): boolean { + return (this.projectId === defaultProjectId); + } +} diff --git a/src.ts/providers/provider-ipcsocket-browser.ts b/src.ts/providers/provider-ipcsocket-browser.ts new file mode 100644 index 000000000..4f11ba6a5 --- /dev/null +++ b/src.ts/providers/provider-ipcsocket-browser.ts @@ -0,0 +1,3 @@ +const IpcSocketProvider = undefined; + +export { IpcSocketProvider }; diff --git a/src.ts/providers/provider-ipcsocket.ts b/src.ts/providers/provider-ipcsocket.ts new file mode 100644 index 000000000..3461d2a1a --- /dev/null +++ b/src.ts/providers/provider-ipcsocket.ts @@ -0,0 +1,98 @@ + +import { connect } from "net"; +import { SocketProvider } from "./provider-socket.js"; + +import type { Socket } from "net"; +import type { Networkish } from "./network.js"; + + +// @TODO: Is this sufficient? Is this robust? Will newlines occur between +// all payloads and only between payloads? +function splitBuffer(data: Buffer): { messages: Array, remaining: Buffer } { + const messages: Array = [ ]; + + let lastStart = 0; + while (true) { + const nl = data.indexOf(10, lastStart); + if (nl === -1) { break; } + messages.push(data.subarray(lastStart, nl).toString().trim()); + lastStart = nl + 1; + } + + return { messages, remaining: data.subarray(lastStart) }; +} + +export class IpcSocketProvider extends SocketProvider { + #socket: Socket; + get socket(): Socket { return this.#socket; } + + constructor(path: string, network?: Networkish) { + super(network); + this.#socket = connect(path); + + this.socket.on("ready", () => { this._start(); }); + + let response = Buffer.alloc(0); + this.socket.on("data", (data) => { + response = Buffer.concat([ response, data ]); + const { messages, remaining } = splitBuffer(response); + messages.forEach((message) => { + this._processMessage(message); + }); + response = remaining; + }); + + this.socket.on("end", () => { + this.emit("close"); + this.socket.destroy(); + this.socket.end(); + }); + } + + stop(): void { + this.socket.destroy(); + this.socket.end(); + } + + async _write(message: string): Promise { + console.log(">>>", message); + this.socket.write(message); + } +} +/* + +import { defineProperties } from "@ethersproject/properties"; + +import { SocketLike, SocketProvider } from "./provider-socket.js"; + +import type { Socket } from "net"; + +export class SocketWrapper implements SocketLike { + #socket: Socket; + + constructor(path: string) { + this.#socket = connect(path); + } + + send(data: string): void { + this.#socket.write(data, () => { }); + } + + addEventListener(event: string, listener: (data: string) => void): void { + //this.#socket.on(event, (value: ) => { + //}); + } + + close(): void { + } +} + +export class IpcProvider extends SocketProvider { + readonly path!: string; + + constructor(path: string) { + super(new SocketWrapper(path)); + defineProperties(this, { path }); + } +} +*/ diff --git a/src.ts/providers/provider-jsonrpc.ts b/src.ts/providers/provider-jsonrpc.ts new file mode 100644 index 000000000..a23f1a204 --- /dev/null +++ b/src.ts/providers/provider-jsonrpc.ts @@ -0,0 +1,853 @@ +// @TODO: +// - Add the batching API + +// https://playground.open-rpc.org/?schemaUrl=https://raw.githubusercontent.com/ethereum/eth1.0-apis/assembled-spec/openrpc.json&uiSchema%5BappBar%5D%5Bui:splitView%5D=true&uiSchema%5BappBar%5D%5Bui:input%5D=false&uiSchema%5BappBar%5D%5Bui:examplesDropdown%5D=false + +import { resolveAddress } from "../address/index.js"; +import { hexlify } from "../utils/data.js"; +import { FetchRequest } from "../utils/fetch.js"; +import { toQuantity } from "../utils/maths.js"; +import { defineProperties } from "../utils/properties.js"; +import { TypedDataEncoder } from "../hash/typed-data.js"; +import { toUtf8Bytes } from "../utils/utf8.js"; +import { accessListify } from "../transaction/index.js"; + +import { AbstractProvider, UnmanagedSubscriber } from "./abstract-provider.js"; +import { AbstractSigner } from "./abstract-signer.js"; +import { Network } from "./network.js"; +import { FilterIdEventSubscriber, FilterIdPendingSubscriber } from "./subscriber-filterid.js"; + +import type { TypedDataDomain, TypedDataField } from "../hash/index.js"; +import type { TransactionLike } from "../transaction/index.js"; + +import type { PerformActionRequest, Subscriber, Subscription } from "./abstract-provider.js"; +import type { Networkish } from "./network.js"; +import type { Provider, TransactionRequest, TransactionResponse } from "./provider.js"; +import type { Signer } from "./signer.js"; + +import { logger } from "../utils/logger.js"; + + +//function copy(value: T): T { +// return JSON.parse(JSON.stringify(value)); +//} + +const Primitive = "bigint,boolean,function,number,string,symbol".split(/,/g); +//const Methods = "getAddress,then".split(/,/g); +function deepCopy(value: T): T { + if (value == null || Primitive.indexOf(typeof(value)) >= 0) { + return value; + } + + // Keep any Addressable + if (typeof((value).getAddress) === "function") { + return value; + } + + if (Array.isArray(value)) { return (value.map(deepCopy)); } + + if (typeof(value) === "object") { + return Object.keys(value).reduce((accum, key) => { + accum[key] = (value)[key]; + return accum; + }, { }); + } + + throw new Error(`should not happen: ${ value } (${ typeof(value) })`); +} + +function getLowerCase(value: string): string { + if (value) { return value.toLowerCase(); } + return value; +} + +interface Pollable { + pollingInterval: number; +} + +function isPollable(value: any): value is Pollable { + return (value && typeof(value.pollingInterval) === "number"); +} + +export type JsonRpcPayload = { + id: number; + method: string; + params: Array | Record; + jsonrpc: "2.0"; +}; + +export type JsonRpcResult = { + id: number; + result: any; +}; + +export type JsonRpcError = { + id: number; + error: { + code: number; + message?: string; + data?: any; + } +}; + +export type JsonRpcOptions = { + // Whether to immediately fallback onto useing the polling strategy; otherwise + // attempt to use filters first, falling back onto polling if filter returns failure + polling?: boolean; + + // Whether to check the network on each call; only set this to true when a backend + // **cannot** change otherwise catastrophic errors can occur + staticNetwork?: null | Network; + + // How long to wait before draining the payload queue + batchStallTime?: number; + + // Maximum estimated size (in bytes) to allow in a batch + batchMaxSize?: number; + + // Maximum number of payloads to send per batch; if set to 1, non-batching requests + // are made. + batchMaxCount?: number; +}; + +const defaultOptions = { + polling: false, + staticNetwork: null, + + batchStallTime: 10, // 10ms + batchMaxSize: (1 << 20), // 1Mb + batchMaxCount: 100 // 100 requests +} + +export interface JsonRpcTransactionRequest { + from?: string; + to?: string; + data?: string; + + chainId?: string; + type?: string; + gas?: string; + + gasPrice?: string; + maxFeePerGas?: string; + maxPriorityFeePerGas?: string; + + nonce?: string; + value?: string; + + accessList?: Array<{ address: string, storageKeys: Array }>; +} + +// @TODO: Unchecked Signers + +export class JsonRpcSigner extends AbstractSigner { + address!: string; + + constructor(provider: JsonRpcApiProvider, address: string) { + super(provider); + defineProperties(this, { address }); + } + + connect(provider: null | Provider): Signer { + return logger.throwError("cannot reconnect JsonRpcSigner", "UNSUPPORTED_OPERATION", { + operation: "signer.connect" + }); + } + + async getAddress(): Promise { + return this.address; + } + + // JSON-RPC will automatially fill in nonce, etc. so we just check from + async populateTransaction(tx: TransactionRequest): Promise> { + return await this.populateCall(tx); + } + + //async getNetwork(): Promise> { + // return await this.provider.getNetwork(); + //} + + //async estimateGas(tx: TransactionRequest): Promise { + // return await this.provider.estimateGas(tx); + //} + + //async call(tx: TransactionRequest): Promise { + // return await this.provider.call(tx); + //} + + //async resolveName(name: string | Addressable): Promise { + // return await this.provider.resolveName(name); + //} + + //async getNonce(blockTag?: BlockTag): Promise { + // return await this.provider.getTransactionCountOf(this.address); + //} + + // Returns just the hash of the transaction after sent, which is what + // the bare JSON-RPC API does; + async sendUncheckedTransaction(_tx: TransactionRequest): Promise { + const tx = deepCopy(_tx); + + const promises: Array> = []; + + // Make sure the from matches the sender + if (tx.from) { + const _from = tx.from; + promises.push((async () => { + const from = await resolveAddress(_from, this.provider); + if (from == null || from.toLowerCase() !== this.address.toLowerCase()) { + logger.throwArgumentError("from address mismatch", "transaction", _tx); + } + tx.from = from; + })()); + } else { + tx.from = this.address; + } + + // The JSON-RPC for eth_sendTransaction uses 90000 gas; if the user + // wishes to use this, it is easy to specify explicitly, otherwise + // we look it up for them. + if (tx.gasLimit == null) { + promises.push((async () => { + tx.gasLimit = await this.provider.estimateGas({ ...tx, from: this.address}); + })()); + } + + // The address may be an ENS name or Addressable + if (tx.to != null) { + const _to = tx.to; + promises.push((async () => { + tx.to = await resolveAddress(_to, this.provider); + })()); + } + + // Wait until all of our properties are filled in + if (promises.length) { await Promise.all(promises); } + + const hexTx = this.provider.getRpcTransaction(tx); + + return this.provider.send("eth_sendTransaction", [ hexTx ]); + } + + async sendTransaction(tx: TransactionRequest): Promise { + // This cannot be mined any earlier than any recent block + const blockNumber = await this.provider.getBlockNumber(); + + // Send the transaction + const hash = await this.sendUncheckedTransaction(tx); + + // Unfortunately, JSON-RPC only provides and opaque transaction hash + // for a response, and we need the actual transaction, so we poll + // for it; it should show up very quickly + return await (new Promise((resolve, reject) => { + const timeouts = [ 1000, 100 ]; + const checkTx = async () => { + // Try getting the transaction + const tx = await this.provider.getTransaction(hash); + if (tx != null) { + resolve(this.provider._wrapTransaction(tx, hash, blockNumber)); + return; + } + + // Wait another 4 seconds + this.provider._setTimeout(() => { checkTx(); }, timeouts.pop() || 4000); + }; + checkTx(); + })); + } + + async signTransaction(_tx: TransactionRequest): Promise { + const tx = deepCopy(_tx); + + // Make sure the from matches the sender + if (tx.from) { + const from = await resolveAddress(tx.from, this.provider); + if (from == null || from.toLowerCase() !== this.address.toLowerCase()) { + return logger.throwArgumentError("from address mismatch", "transaction", _tx); + } + tx.from = from; + } else { + tx.from = this.address; + } + + const hexTx = this.provider.getRpcTransaction(tx); + return await this.provider.send("eth_sign_Transaction", [ hexTx ]); + } + + + async signMessage(_message: string | Uint8Array): Promise { + const message = ((typeof(_message) === "string") ? toUtf8Bytes(_message): _message); + return await this.provider.send("personal_sign", [ + hexlify(message), this.address.toLowerCase() ]); + } + + async signTypedData(domain: TypedDataDomain, types: Record>, _value: Record): Promise { + const value = deepCopy(_value); + + // Populate any ENS names (in-place) + const populated = await TypedDataEncoder.resolveNames(domain, types, value, async (value: string) => { + const address = await resolveAddress(value); + if (address == null) { + return logger.throwArgumentError("TypedData does not support null address", "value", value); + } + return address; + }); + + return await this.provider.send("eth_signTypedData_v4", [ + this.address.toLowerCase(), + JSON.stringify(TypedDataEncoder.getPayload(populated.domain, types, populated.value)) + ]); + } + + async unlock(password: string): Promise { + return this.provider.send("personal_unlockAccount", [ + this.address.toLowerCase(), password, null ]); + } + + // https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign + async _legacySignMessage(_message: string | Uint8Array): Promise { + const message = ((typeof(_message) === "string") ? toUtf8Bytes(_message): _message); + return await this.provider.send("eth_sign", [ + this.address.toLowerCase(), hexlify(message) ]); + } +} + +type ResolveFunc = (result: JsonRpcResult) => void; +type RejectFunc = (error: Error) => void; + +type Payload = { payload: JsonRpcPayload, resolve: ResolveFunc, reject: RejectFunc }; + +export class JsonRpcApiProvider extends AbstractProvider { + + #options: Required; + + #nextId: number; + #payloads: Array; + #drainTimer: null | NodeJS.Timer; + + constructor(network?: Networkish, options?: JsonRpcOptions) { + super(network); + + this.#nextId = 1; + this.#options = Object.assign({ }, defaultOptions, options || { }); + + this.#payloads = [ ]; + this.#drainTimer = null; + + // This could be relaxed in the future to just check equivalent networks + const staticNetwork = this._getOption("staticNetwork"); + if (staticNetwork && staticNetwork !== network) { + logger.throwArgumentError("staticNetwork MUST match network object", "options", options); + } + } + + _getOption(key: K): JsonRpcOptions[K] { + return this.#options[key]; + } + + // @TODO: Merge this into send + //prepareRequest(method: string, params: Array): JsonRpcPayload { + // return { + // method, params, id: (this.#nextId++), jsonrpc: "2.0" + // }; + //} +/* + async send(method: string, params: Array): Promise { + // @TODO: This should construct and queue the payload + throw new Error("sub-class must implement this"); + } +*/ + + #scheduleDrain(): void { + if (this.#drainTimer) { return; } + + this.#drainTimer = setTimeout(() => { + this.#drainTimer = null; + + const payloads = this.#payloads; + this.#payloads = [ ]; + + while (payloads.length) { + + // Create payload batches that satisfy our batch constraints + const batch = [ (payloads.shift()) ]; + while (payloads.length) { + if (batch.length === this.#options.batchMaxCount) { break; } + batch.push((payloads.shift())); + const bytes = JSON.stringify(batch.map((p) => p.payload)); + if (bytes.length > this.#options.batchMaxSize) { + payloads.unshift((batch.pop())); + break; + } + } + + // Process the result to each payload + (async () => { + const payload = ((batch.length === 1) ? batch[0].payload: batch.map((p) => p.payload)); + + this.emit("debug", { action: "sendRpcPayload", payload }); + + try { + const result = await this._send(payload); + this.emit("debug", { action: "receiveRpcResult", result }); + + // Process results in batch order + for (const { resolve, reject, payload } of batch) { + + // Find the matching result + const resp = result.filter((r) => (r.id === payload.id))[0]; + + // No result; the node failed us in unexpected ways + if (resp == null) { + return reject(new Error("@TODO: no result")); + } + + // The response is an error + if ("error" in resp) { + return reject(this.getRpcError(payload, resp)); + + } + + // All good; send the result + resolve(resp.result); + } + + } catch (error: any) { + this.emit("debug", { action: "receiveRpcError", error }); + + for (const { reject } of batch) { + // @TODO: augment the error with the payload + reject(error); + } + } + })(); + } + }, this.#options.batchStallTime); + } + + // Sub-classes should **NOT** override this + send(method: string, params: Array | Record): Promise { + // @TODO: cache chainId?? purge on switch_networks + + const id = this.#nextId++; + const promise = new Promise((resolve, reject) => { + this.#payloads.push({ + resolve, reject, + payload: { method, params, id, jsonrpc: "2.0" } + }); + }); + + // If there is not a pending drainTimer, set one + this.#scheduleDrain(); + + return >promise; + } + + // Sub-classes MUST override this + _send(payload: JsonRpcPayload | Array): Promise> { + return logger.throwError("sub-classes must override _send", "UNSUPPORTED_OPERATION", { + operation: "jsonRpcApiProvider._send" + }); + } + + async getSigner(address: number | string = 0): Promise { + + const accountsPromise = this.send("eth_accounts", [ ]); + + // Account index + if (typeof(address) === "number") { + const accounts = >(await accountsPromise); + if (address > accounts.length) { throw new Error("no such account"); } + return new JsonRpcSigner(this, accounts[address]); + } + + const [ network, accounts ] = await Promise.all([ this.getNetwork(), accountsPromise ]); + + // Account address + address = network.formatter.address(address); + for (const account of accounts) { + if (network.formatter.address(account) === account) { + return new JsonRpcSigner(this, account); + } + } + + throw new Error("invalid account"); + } + + // Sub-classes can override this; it detects the *actual* network we + // are connected to + async _detectNetwork(): Promise { + // We have a static network (like INFURA) + const network = this._getOption("staticNetwork"); + if (network) { return network; } + + return Network.from(logger.getBigInt(await this._perform({ method: "chainId" }))); + } + + _getSubscriber(sub: Subscription): Subscriber { + // Pending Filters aren't availble via polling + if (sub.type === "pending") { return new FilterIdPendingSubscriber(this); } + + if (sub.type === "event") { + return new FilterIdEventSubscriber(this, sub.filter); + } + + // Orphaned Logs are handled automatically, by the filter, since + // logs with removed are emitted by it + if (sub.type === "orphan" && sub.filter.orphan === "drop-log") { + return new UnmanagedSubscriber("orphan"); + } + + return super._getSubscriber(sub); + } + + // Normalize a JSON-RPC transaction + getRpcTransaction(tx: TransactionRequest): JsonRpcTransactionRequest { + const result: JsonRpcTransactionRequest = {}; + + // JSON-RPC now requires numeric values to be "quantity" values + ["chainId", "gasLimit", "gasPrice", "type", "maxFeePerGas", "maxPriorityFeePerGas", "nonce", "value"].forEach((key) => { + if ((tx)[key] == null) { return; } + let dstKey = key; + if (key === "gasLimit") { dstKey = "gas"; } + (result)[dstKey] = toQuantity(logger.getBigInt((tx)[key], `tx.${ key }`)); + }); + + // Make sure addresses and data are lowercase + ["from", "to", "data"].forEach((key) => { + if ((tx)[key] == null) { return; } + (result)[key] = hexlify((tx)[key]); + }); + + // Normalize the access list object + if (tx.accessList) { + result["accessList"] = accessListify(tx.accessList); + } + + return result; + } + + // Get the necessary paramters for making a JSON-RPC request + getRpcRequest(req: PerformActionRequest): null | { method: string, args: Array } { + switch (req.method) { + case "chainId": + return { method: "eth_chainId", args: [ ] }; + + case "getBlockNumber": + return { method: "eth_blockNumber", args: [ ] }; + + case "getGasPrice": + return { method: "eth_gasPrice", args: [] }; + + case "getBalance": + return { + method: "eth_getBalance", + args: [ getLowerCase(req.address), req.blockTag ] + }; + + case "getTransactionCount": + return { + method: "eth_getTransactionCount", + args: [ getLowerCase(req.address), req.blockTag ] + }; + + case "getCode": + return { + method: "eth_getCode", + args: [ getLowerCase(req.address), req.blockTag ] + }; + + case "getStorageAt": + return { + method: "eth_getStorageAt", + args: [ + getLowerCase(req.address), + ("0x" + req.position.toString(16)), + req.blockTag + ] + }; + + case "broadcastTransaction": + return { + method: "eth_sendRawTransaction", + args: [ req.signedTransaction ] + }; + + case "getBlock": + if ("blockTag" in req) { + return { + method: "eth_getBlockByNumber", + args: [ req.blockTag, !!req.includeTransactions ] + }; + } else if ("blockHash" in req) { + return { + method: "eth_getBlockByHash", + args: [ req.blockHash, !!req.includeTransactions ] + }; + } + break; + + case "getTransaction": + return { + method: "eth_getTransactionByHash", + args: [ req.hash ] + }; + + case "getTransactionReceipt": + return { + method: "eth_getTransactionReceipt", + args: [ req.hash ] + }; + + case "call": + return { + method: "eth_call", + args: [ this.getRpcTransaction(req.transaction), req.blockTag ] + }; + + case "estimateGas": { + return { + method: "eth_estimateGas", + args: [ this.getRpcTransaction(req.transaction) ] + }; + } + + case "getLogs": + if (req.filter && req.filter.address != null) { + if (Array.isArray(req.filter.address)) { + req.filter.address = req.filter.address.map(getLowerCase); + } else { + req.filter.address = getLowerCase(req.filter.address); + } + } + return { method: "eth_getLogs", args: [ req.filter ] }; + } + + return null; + } + + getRpcError(payload: JsonRpcPayload, error: JsonRpcError): Error { + console.log("getRpcError", payload, error); + return new Error(`JSON-RPC badness; @TODO: ${ error }`); + /* + if (payload.method === "eth_call") { + const result = spelunkData(error); + if (result) { + // @TODO: Extract errorSignature, errorName, errorArgs, reason if + // it is Error(string) or Panic(uint25) + return logger.makeError("execution reverted during JSON-RPC call", "CALL_EXCEPTION", { + data: result.data, + transaction: args[0] + }); + } + + return logger.makeError("missing revert data during JSON-RPC call", "CALL_EXCEPTION", { + data: "0x", transaction: args[0], info: { error } + }); + } + + if (method === "eth_estimateGas") { + // @TODO: Spelunk, and adapt the above to allow missing data. + // Then throw an UNPREDICTABLE_GAS exception + } + + const message = JSON.stringify(spelunkMessage(error)); + + if (message.match(/insufficient funds|base fee exceeds gas limit/)) { + return logger.makeError("insufficient funds for intrinsic transaction cost", "INSUFFICIENT_FUNDS", { + transaction: args[0] + }); + } + + if (message.match(/nonce/) && message.match(/too low/)) { + return logger.makeError("nonce has already been used", "NONCE_EXPIRED", { + transaction: args[0] + }); + } + + // "replacement transaction underpriced" + if (message.match(/replacement transaction/) && message.match(/underpriced/)) { + return logger.makeError("replacement fee too low", "REPLACEMENT_UNDERPRICED", { + transaction: args[0] + }); + } + + if (message.match(/only replay-protected/)) { + return logger.makeError("legacy pre-eip-155 transactions not supported", "UNSUPPORTED_OPERATION", { + operation: method, info: { transaction: args[0] } + }); + } + + if (method === "estimateGas" && message.match(/gas required exceeds allowance|always failing transaction|execution reverted/)) { + return logger.makeError("cannot estimate gas; transaction may fail or may require manual gas limit", "UNPREDICTABLE_GAS_LIMIT", { + transaction: args[0] + }); + } + + return error; + */ + } + + async _perform(req: PerformActionRequest): Promise { + // Legacy networks do not like the type field being passed along (which + // is fair), so we delete type if it is 0 and a non-EIP-1559 network + if (req.method === "call" || req.method === "estimateGas") { + let tx = req.transaction; + if (tx && tx.type != null && logger.getBigInt(tx.type)) { + // If there are no EIP-1559 properties, it might be non-EIP-a559 + if (tx.maxFeePerGas == null && tx.maxPriorityFeePerGas == null) { + const feeData = await this.getFeeData(); + if (feeData.maxFeePerGas == null && feeData.maxPriorityFeePerGas == null) { + // Network doesn't know about EIP-1559 (and hence type) + req = Object.assign({ }, req, { + transaction: Object.assign({ }, tx, { type: undefined }) + }); + } + } + } + } + + const request = this.getRpcRequest(req); + + if (request != null) { + return await this.send(request.method, request.args); + +/* + @TODO: Add debug output to send + this.emit("debug", { type: "sendRequest", request }); + try { + const result = + //console.log("RR", result); + this.emit("debug", { type: "getResponse", result }); + return result; + } catch (error) { + this.emit("debug", { type: "getError", error }); + throw error; + //throw this.getRpcError(request.method, request.args, error); + } +*/ + } + + return super._perform(req); + } +} + +export class JsonRpcProvider extends JsonRpcApiProvider { + #connect: FetchRequest; + + #pollingInterval: number; + + constructor(url?: string | FetchRequest, network?: Networkish, options?: JsonRpcOptions) { + if (url == null) { url = "http:/\/localhost:8545"; } + super(network, options); + + if (typeof(url) === "string") { + this.#connect = new FetchRequest(url); + } else { + this.#connect = url.clone(); + } + + this.#pollingInterval = 4000; + } + + async _send(payload: JsonRpcPayload | Array): Promise> { + // Configure a POST connection for the requested method + const request = this.#connect.clone(); + request.body = JSON.stringify(payload); + + const response = await request.send(); + response.assertOk(); + + let resp = response.bodyJson; + if (!Array.isArray(resp)) { resp = [ resp ]; } + + return resp; + } + + get pollingInterval(): number { return this.#pollingInterval; } + set pollingInterval(value: number) { + if (!Number.isInteger(value) || value < 0) { throw new Error("invalid interval"); } + this.#pollingInterval = value; + this._forEachSubscriber((sub) => { + if (isPollable(sub)) { + sub.pollingInterval = this.#pollingInterval; + } + }); + } +} + +// This class should only be used when it is not possible for the +// underlying network to change, such as with INFURA. If you are +// using MetaMask or some other client which allows users to change +// their network DO NOT USE THIS. Bad things will happen. +/* +export class StaticJsonRpcProvider extends JsonRpcProvider { + readonly network!: Network; + + constructor(url: string | ConnectionInfo, network?: Network, options?: JsonRpcOptions) { + super(url, network, options); + defineProperties(this, { network }); + } + + async _detectNetwork(): Promise { + return this.network; + } +} +*/ +/* +function spelunkData(value: any): null | { message: string, data: string } { + if (value == null) { return null; } + + // These *are* the droids we're looking for. + if (typeof(value.message) === "string" && value.message.match("reverted") && isHexString(value.data)) { + return { message: value.message, data: value.data }; + } + + // Spelunk further... + if (typeof(value) === "object") { + for (const key in value) { + const result = spelunkData(value[key]); + if (result) { return result; } + } + return null; + } + + // Might be a JSON string we can further descend... + if (typeof(value) === "string") { + try { + return spelunkData(JSON.parse(value)); + } catch (error) { } + } + + return null; +} + +function _spelunkMessage(value: any, result: Array): void { + if (value == null) { return; } + + // These *are* the droids we're looking for. + if (typeof(value.message) === "string") { + result.push(value.message); + } + + // Spelunk further... + if (typeof(value) === "object") { + for (const key in value) { + _spelunkMessage(value[key], result); + } + } + + // Might be a JSON string we can further descend... + if (typeof(value) === "string") { + try { + return _spelunkMessage(JSON.parse(value), result); + } catch (error) { } + } +} + +function spelunkMessage(value: any): Array { + const result: Array = [ ]; + _spelunkMessage(value, result); + return result; +} +*/ diff --git a/src.ts/providers/provider-pocket.ts b/src.ts/providers/provider-pocket.ts new file mode 100644 index 000000000..9b6e3eeb6 --- /dev/null +++ b/src.ts/providers/provider-pocket.ts @@ -0,0 +1,99 @@ +/* +import { defineProperties } from "../utils/properties.js"; +import { FetchRequest } from "../web/index.js"; + +import { showThrottleMessage } from "./community.js"; +import { logger } from "../utils/logger.js"; +import { Network } from "./network.js"; +import { JsonRpcProvider } from "./provider-jsonrpc.js"; + +import type { ConnectionInfo, ThrottleRetryFunc } from "../web/index.js"; + +import type { CommunityResourcable } from "./community.js"; +import type { Networkish } from "./network.js"; + + + +// These are load-balancer-based application IDs +const defaultAppIds: Record = { + homestead: "6004bcd10040261633ade990", + ropsten: "6004bd4d0040261633ade991", + rinkeby: "6004bda20040261633ade994", + goerli: "6004bd860040261633ade992", +}; + +function getHost(name: string): string { + switch(name) { + case "homestead": + return "eth-mainnet.gateway.pokt.network"; + case "ropsten": + return "eth-ropsten.gateway.pokt.network"; + case "rinkeby": + return "eth-rinkeby.gateway.pokt.network"; + case "goerli": + return "eth-goerli.gateway.pokt.network"; + } + + return logger.throwArgumentError("unsupported network", "network", name); +} + +function normalizeApiKey(network: Network, _appId?: null | string, applicationSecretKey?: null | string, loadBalancer?: boolean): { applicationId: string, applicationSecretKey: null | string, loadBalancer: boolean, community: boolean } { + loadBalancer = !!loadBalancer; + + let community = false; + let applicationId = _appId; + if (applicationId == null) { + applicationId = defaultAppIds[network.name]; + if (applicationId == null) { + logger.throwArgumentError("network does not support default applicationId", "applicationId", _appId); + } + loadBalancer = true; + community = true; + } else if (applicationId === defaultAppIds[network.name]) { + loadBalancer = true; + community = true; + } + if (applicationSecretKey == null) { applicationSecretKey = null; } + + return { applicationId, applicationSecretKey, community, loadBalancer }; +} + +export class PocketProvider extends JsonRpcProvider implements CommunityResourcable { + readonly applicationId!: string; + readonly applicationSecretKey!: null | string; + readonly loadBalancer!: boolean; + + constructor(_network: Networkish = "homestead", _appId?: null | string, _secretKey?: null | string, _loadBalancer?: boolean) { + const network = Network.from(_network); + const { applicationId, applicationSecretKey, loadBalancer } = normalizeApiKey(network, _appId, _secretKey, _loadBalancer); + + const connection = PocketProvider.getConnection(network, applicationId, applicationSecretKey, loadBalancer); + super(connection, network, { staticNetwork: network }); + + defineProperties(this, { applicationId, applicationSecretKey, loadBalancer }); + } + + static getConnection(network: Network, _appId?: null | string, _secretKey?: null | string, _loadBalancer?: boolean): ConnectionInfo { + const { applicationId, applicationSecretKey, community, loadBalancer } = normalizeApiKey(network, _appId, _secretKey, _loadBalancer); + + let url = `https:/\/${ getHost(network.name) }/v1/`; + if (loadBalancer) { url += "lb/"; } + url += applicationId; + + const request = new FetchRequest(url); + request.allowGzip = true; + if (applicationSecretKey) { request.setCredentials("", applicationSecretKey); } + + const throttleRetry: ThrottleRetryFunc = async (request, response, attempt) => { + if (community) { showThrottleMessage("PocketProvider"); } + return true; + }; + + return { request, throttleRetry }; + } + + isCommunityResource(): boolean { + return (this.applicationId === defaultAppIds[this.network.name]); + } +} +*/ diff --git a/src.ts/providers/provider-socket.ts b/src.ts/providers/provider-socket.ts new file mode 100644 index 000000000..c37163d80 --- /dev/null +++ b/src.ts/providers/provider-socket.ts @@ -0,0 +1,259 @@ +/** + * SocketProvider + * + * Generic long-lived socket provider. + * + * Sub-classing notes + * - a sub-class MUST call the `_start()` method once connected + * - a sub-class MUST override the `_write(string)` method + * - a sub-class MUST call `_processMessage(string)` for each message + */ + +import { UnmanagedSubscriber } from "./abstract-provider.js"; +import { assertArgument, logger } from "../utils/logger.js"; +import { JsonRpcApiProvider } from "./provider-jsonrpc.js"; + +import type { Subscriber, Subscription } from "./abstract-provider.js"; +import type { Formatter } from "./formatter.js"; +import type { EventFilter } from "./provider.js"; +import type { JsonRpcError, JsonRpcPayload, JsonRpcResult } from "./provider-jsonrpc.js"; +import type { Networkish } from "./network.js"; + + +type JsonRpcSubscription = { + method: string, + params: { + result: any, + subscription: string + } +}; + +export class SocketSubscriber implements Subscriber { + #provider: SocketProvider; + + #filter: string; + get filter(): Array { return JSON.parse(this.#filter); } + + #filterId: null | Promise; + #paused: null | boolean; + + #emitPromise: null | Promise; + + constructor(provider: SocketProvider, filter: Array) { + this.#provider = provider; + this.#filter = JSON.stringify(filter); + this.#filterId = null; + this.#paused = null; + this.#emitPromise = null; + } + + start(): void { + this.#filterId = this.#provider.send("eth_subscribe", this.filter).then((filterId) => {; + this.#provider._register(filterId, this); + return filterId; + }); + } + + stop(): void { + (>(this.#filterId)).then((filterId) => { + this.#provider.send("eth_unsubscribe", [ filterId ]); + }); + this.#filterId = null; + } + + // @TODO: pause should trap the current blockNumber, unsub, and on resume use getLogs + // and resume + pause(dropWhilePaused?: boolean): void { + if (!dropWhilePaused) { + logger.throwError("preserve logs while paused not supported by SocketSubscriber yet", "UNSUPPORTED_OPERATION", { + operation: "pause(false)" + }); + } + this.#paused = !!dropWhilePaused; + } + + resume(): void { + this.#paused = null; + } + + _handleMessage(message: any): void { + if (this.#filterId == null) { return; } + if (this.#paused === null) { + let emitPromise: null | Promise = this.#emitPromise; + if (emitPromise == null) { + emitPromise = this._emit(this.#provider, message); + } else { + emitPromise = emitPromise.then(async () => { + await this._emit(this.#provider, message); + }); + } + this.#emitPromise = emitPromise.then(() => { + if (this.#emitPromise === emitPromise) { + this.#emitPromise = null; + } + }); + } + } + + async _emit(provider: SocketProvider, message: any): Promise { + throw new Error("sub-classes must implemente this; _emit"); + } +} + +export class SocketBlockSubscriber extends SocketSubscriber { + constructor(provider: SocketProvider) { + super(provider, [ "newHeads" ]); + } + + async _emit(provider: SocketProvider, message: any): Promise { + provider.emit("block", parseInt(message.number)); + } +} + +export class SocketPendingSubscriber extends SocketSubscriber { + constructor(provider: SocketProvider) { + super(provider, [ "newPendingTransactions" ]); + } + + async _emit(provider: SocketProvider, message: any): Promise { + provider.emit("pending", message); + } +} + +export class SocketEventSubscriber extends SocketSubscriber { + #logFilter: string; + get logFilter(): EventFilter { return JSON.parse(this.#logFilter); } + + #formatter: Promise>; + + constructor(provider: SocketProvider, filter: EventFilter) { + super(provider, [ "logs", filter ]); + this.#logFilter = JSON.stringify(filter); + this.#formatter = provider.getNetwork().then((network) => network.formatter); + } + + async _emit(provider: SocketProvider, message: any): Promise { + const formatter = await this.#formatter; + provider.emit(this.#logFilter, formatter.log(message, provider)); + } +} + +export class SocketProvider extends JsonRpcApiProvider { + #callbacks: Map void, reject: (e: Error) => void }>; + + #ready: boolean; + + // Maps each filterId to its subscriber + #subs: Map; + + // If any events come in before a subscriber has finished + // registering, queue them + #pending: Map>; + + constructor(network?: Networkish) { + super(network, { batchMaxCount: 1 }); + this.#callbacks = new Map(); + this.#ready = false; + this.#subs = new Map(); + this.#pending = new Map(); + } + + _getSubscriber(sub: Subscription): Subscriber { + switch (sub.type) { + case "close": + return new UnmanagedSubscriber("close"); + case "block": + return new SocketBlockSubscriber(this); + case "pending": + return new SocketPendingSubscriber(this); + case "event": + return new SocketEventSubscriber(this, sub.filter); + case "orphan": + // Handled auto-matically within AbstractProvider + // when the log.removed = true + if (sub.filter.orphan === "drop-log") { + return new UnmanagedSubscriber("drop-log"); + } + } + return super._getSubscriber(sub); + } + + _register(filterId: number | string, subscriber: SocketSubscriber): void { + this.#subs.set(filterId, subscriber); + const pending = this.#pending.get(filterId); + if (pending) { + for (const message of pending) { + subscriber._handleMessage(message); + } + this.#pending.delete(filterId); + } + } + + async _send(payload: JsonRpcPayload | Array): Promise> { + // WebSocket provider doesn't accept batches + assertArgument(!Array.isArray(payload), "WebSocket does not support batch send", "payload", payload); + + // @TODO: stringify payloads here and store to prevent mutations + const promise = new Promise((resolve, reject) => { + this.#callbacks.set(payload.id, { payload, resolve, reject }); + }); + + if (this.#ready) { + await this._write(JSON.stringify(payload)); + } + + return >[ await promise ]; + } + + // Sub-classes must call this once they are connected + async _start(): Promise { + if (this.#ready) { return; } + this.#ready = true; + for (const { payload } of this.#callbacks.values()) { + await this._write(JSON.stringify(payload)); + } + } + + // Sub-classes must call this for each message + async _processMessage(message: string): Promise { + const result = (JSON.parse(message)); + + if ("id" in result) { + const callback = this.#callbacks.get(result.id); + if (callback == null) { + console.log("Weird... Response for not a thing we sent"); + return; + } + this.#callbacks.delete(result.id); + + if ("error" in result) { + const { message, code, data } = result.error; + const error = logger.makeError(message || "unkonwn error", "SERVER_ERROR", { + request: `ws:${ JSON.stringify(callback.payload) }`, + info: { code, data } + }); + callback.reject(error); + } else { + callback.resolve(result.result); + } + + } else if (result.method === "eth_subscription") { + const filterId = result.params.subscription; + const subscriber = this.#subs.get(filterId); + if (subscriber) { + subscriber._handleMessage(result.params.result); + } else { + let pending = this.#pending.get(filterId); + if (pending == null) { + pending = [ ]; + this.#pending.set(filterId, pending); + } + pending.push(result.params.result); + } + } + } + + async _write(message: string): Promise { + throw new Error("sub-classes must override this"); + } +} diff --git a/src.ts/providers/provider-websocket.ts b/src.ts/providers/provider-websocket.ts new file mode 100644 index 000000000..1774d68d6 --- /dev/null +++ b/src.ts/providers/provider-websocket.ts @@ -0,0 +1,46 @@ + + +import { WebSocket as _WebSocket } from "./ws.js"; /*-browser*/ + +import { SocketProvider } from "./provider-socket.js"; + +import type { Networkish } from "./network.js"; + +export interface WebSocketLike { + onopen: null | ((...args: Array) => any); + onmessage: null | ((...args: Array) => any); + onerror: null | ((...args: Array) => any); + + readyState: number; + + send(payload: any): void; + close(code?: number, reason?: string): void; +} + +export class WebSocketProvider extends SocketProvider { + url!: string; + + #websocket: WebSocketLike; + get websocket(): WebSocketLike { return this.#websocket; } + + constructor(url: string | WebSocketLike, network?: Networkish) { + super(network); + if (typeof(url) === "string") { + this.#websocket = new _WebSocket(url); + } else { + this.#websocket = url; + } + + this.websocket.onopen = () => { + this._start(); + }; + + this.websocket.onmessage = (message: { data: string }) => { + this._processMessage(message.data); + }; + } + + async _write(message: string): Promise { + this.websocket.send(message); + } +} diff --git a/src.ts/providers/provider.ts b/src.ts/providers/provider.ts new file mode 100644 index 000000000..b238f0b7a --- /dev/null +++ b/src.ts/providers/provider.ts @@ -0,0 +1,1097 @@ +//import { resolveAddress } from "@ethersproject/address"; +import { hexlify } from "../utils/data.js"; +import { logger } from "../utils/logger.js"; +import { defineProperties } from "../utils/properties.js"; +import { accessListify } from "../transaction/index.js"; + + +import type { AddressLike, NameResolver } from "../address/index.js"; +import type { BigNumberish, EventEmitterable, Frozen, Listener } from "../utils/index.js"; +import type { Signature } from "../crypto/index.js"; +import type { AccessList, AccessListish, TransactionLike } from "../transaction/index.js"; + +import type { ContractRunner } from "./contracts.js"; +import type { Network } from "./network.js"; + + +export type BlockTag = number | string; + +// ----------------------- + +function getValue(value: undefined | null | T): null | T { + if (value == null) { return null; } + return value; +} + +function toJson(value: null | bigint): null | string { + if (value == null) { return null; } + return value.toString(); +} + +// @TODO? implements Required +export class FeeData { + readonly gasPrice!: null | bigint; + readonly maxFeePerGas!: null | bigint; + readonly maxPriorityFeePerGas!: null | bigint; + + constructor(gasPrice?: null | bigint, maxFeePerGas?: null | bigint, maxPriorityFeePerGas?: null | bigint) { + defineProperties(this, { + gasPrice: getValue(gasPrice), + maxFeePerGas: getValue(maxFeePerGas), + maxPriorityFeePerGas: getValue(maxPriorityFeePerGas) + }); + } + + toJSON(): any { + const { + gasPrice, maxFeePerGas, maxPriorityFeePerGas + } = this; + return { + _type: "FeeData", + gasPrice: toJson(gasPrice), + maxFeePerGas: toJson(maxFeePerGas), + maxPriorityFeePerGas: toJson(maxPriorityFeePerGas), + }; + } +} + + + +export interface TransactionRequest { + type?: null | number; + + to?: null | AddressLike; + from?: null | AddressLike; + + nonce?: null | number; + + gasLimit?: null | BigNumberish; + gasPrice?: null | BigNumberish; + + maxPriorityFeePerGas?: null | BigNumberish; + maxFeePerGas?: null | BigNumberish; + + data?: null | string; + value?: null | BigNumberish; + chainId?: null | BigNumberish; + + accessList?: null | AccessListish; + + customData?: any; + + // Todo? + //gasMultiplier?: number; +}; + + +export interface CallRequest extends TransactionRequest { + blockTag?: BlockTag; + enableCcipRead?: boolean; +} + +export interface PreparedRequest { + type?: number; + + to?: AddressLike; + from?: AddressLike; + + nonce?: number; + + gasLimit?: bigint; + gasPrice?: bigint; + + maxPriorityFeePerGas?: bigint; + maxFeePerGas?: bigint; + + data?: string; + value?: bigint; + chainId?: bigint; + + accessList?: AccessList; + + customData?: any; + + blockTag?: BlockTag; + enableCcipRead?: boolean; +} + +export function copyRequest(req: CallRequest): PreparedRequest { + const result: any = { }; + + // These could be addresses, ENS names or Addressables + if (req.to) { result.to = req.to; } + if (req.from) { result.from = req.from; } + + if (req.data) { result.data = hexlify(req.data); } + + const bigIntKeys = "chainId,gasLimit,gasPrice,maxFeePerGas, maxPriorityFeePerGas,value".split(/,/); + for (const key in bigIntKeys) { + if (!(key in req) || (req)[key] == null) { continue; } + result[key] = logger.getBigInt((req)[key], `request.${ key }`); + } + + const numberKeys = "type,nonce".split(/,/); + for (const key in numberKeys) { + if (!(key in req) || (req)[key] == null) { continue; } + result[key] = logger.getNumber((req)[key], `request.${ key }`); + } + + if (req.accessList) { + result.accessList = accessListify(req.accessList); + } + + if ("blockTag" in req) { result.blockTag = req.blockTag; } + + if ("enableCcipRead" in req) { + result.enableCcipReadEnabled = !!req.enableCcipRead + } + + if ("customData" in req) { + result.customData = req.customData; + } + + return result; +} + +//Omit, "hash" | "signature">; +/* +export async function resolveTransactionRequest(tx: TransactionRequest, provider?: Provider): Promise { + // A pending transaction with items that may require resolving + const ptx: any = Object.assign({ }, tx); //await resolveProperties(await tx)); + //if (tx.hash != null || tx.signature != null) { + // throw new Error(); + // @TODO: Check for bad keys? + //} + // @TODO: Why does TS not think that to and from are reoslved and require the cast to string + if (ptx.to != null) { ptx.to = resolveAddress((ptx.to), provider); } + if (ptx.from != null) { ptx.from = resolveAddress((ptx.from), provider); } + return await resolveProperties(ptx); +} +*/ + +//function canConnect(value: any): value is T { +// return (value && typeof(value.connect) === "function"); +//} + + +////////////////////// +// Block + +export interface BlockParams { + hash?: null | string; + + number: number; + timestamp: number; + + parentHash: string; + + nonce: string; + difficulty: bigint; + + gasLimit: bigint; + gasUsed: bigint; + + miner: string; + extraData: string; + + baseFeePerGas: null | bigint; + + transactions: ReadonlyArray; +}; + +export interface MinedBlock extends Block { + readonly number: number; + readonly hash: string; + readonly timestamp: number; + readonly date: Date; + readonly miner: string; +} + +export interface LondonBlock extends Block { + readonly baseFeePerGas: bigint; +} + +export class Block implements BlockParams, Iterable { + readonly provider!: Provider; + + readonly number!: number; + readonly hash!: null | string; + readonly timestamp!: number; + + readonly parentHash!: string; + + readonly nonce!: string; + readonly difficulty!: bigint; + + readonly gasLimit!: bigint; + readonly gasUsed!: bigint; + + readonly miner!: string; + readonly extraData!: string; + + readonly baseFeePerGas!: null | bigint; + + readonly #transactions: ReadonlyArray; + + constructor(block: BlockParams, provider?: null | Provider) { + if (provider == null) { provider = dummyProvider; } + + this.#transactions = Object.freeze(block.transactions.map((tx) => { + if (typeof(tx) !== "string" && tx.provider !== provider) { + throw new Error("provider mismatch"); + } + return tx; + }));; + + defineProperties>(this, { + provider, + + hash: getValue(block.hash), + + number: block.number, + timestamp: block.timestamp, + + parentHash: block.parentHash, + + nonce: block.nonce, + difficulty: block.difficulty, + + gasLimit: block.gasLimit, + gasUsed: block.gasUsed, + miner: block.miner, + extraData: block.extraData, + + baseFeePerGas: getValue(block.baseFeePerGas) + }); + } + + get transactions(): ReadonlyArray { return this.#transactions; } + + //connect(provider: Provider): Block { + // return new Block(this, provider); + //} + + toJSON(): any { + const { + baseFeePerGas, difficulty, extraData, gasLimit, gasUsed, hash, + miner, nonce, number, parentHash, timestamp, transactions + } = this; + + return { + _type: "Block", + baseFeePerGas: toJson(baseFeePerGas), + difficulty: toJson(difficulty), + extraData, + gasLimit: toJson(gasLimit), + gasUsed: toJson(gasUsed), + hash, miner, nonce, number, parentHash, timestamp, + transactions, + }; + } + + [Symbol.iterator](): Iterator { + let index = 0; + return { + next: () => { + if (index < this.length) { + return { + value: this.transactions[index++], done: false + } + } + return { value: undefined, done: true }; + } + }; + } + + get length(): number { return this.transactions.length; } + + get date(): null | Date { + if (this.timestamp == null) { return null; } + return new Date(this.timestamp * 1000); + } + + async getTransaction(index: number): Promise { + const tx = this.transactions[index]; + if (tx == null) { throw new Error("no such tx"); } + if (typeof(tx) === "string") { + return (await this.provider.getTransaction(tx)); + } else { + return tx; + } + } + + isMined(): this is MinedBlock { return !!this.hash; } + isLondon(): this is LondonBlock { return !!this.baseFeePerGas; } + + orphanedEvent(): OrphanFilter { + if (!this.isMined()) { throw new Error(""); } + return createOrphanedBlockFilter(this); + } +} + +////////////////////// +// Log + +export interface LogParams { + transactionHash: string; + blockHash: string; + blockNumber: number; + + removed: boolean; + + address: string; + data: string; + + topics: ReadonlyArray; + + index: number; + transactionIndex: number; +} + +export class Log implements LogParams { + readonly provider: Provider; + + readonly transactionHash!: string; + readonly blockHash!: string; + readonly blockNumber!: number; + + readonly removed!: boolean; + + readonly address!: string; + readonly data!: string; + + readonly topics!: ReadonlyArray; + + readonly index!: number; + readonly transactionIndex!: number; + + + constructor(log: LogParams, provider?: null | Provider) { + if (provider == null) { provider = dummyProvider; } + this.provider = provider; + + const topics = Object.freeze(log.topics.slice()); + defineProperties(this, { + transactionHash: log.transactionHash, + blockHash: log.blockHash, + blockNumber: log.blockNumber, + + removed: log.removed, + + address: log.address, + data: log.data, + + topics, + + index: log.index, + transactionIndex: log.transactionIndex, + }); + } + + //connect(provider: Provider): Log { + // return new Log(this, provider); + //} + + toJSON(): any { + const { + address, blockHash, blockNumber, data, index, + removed, topics, transactionHash, transactionIndex + } = this; + + return { + _type: "log", + address, blockHash, blockNumber, data, index, + removed, topics, transactionHash, transactionIndex + }; + } + + async getBlock(): Promise> { + return >(await this.provider.getBlock(this.blockHash)); + } + + async getTransaction(): Promise { + return (await this.provider.getTransaction(this.transactionHash)); + } + + async getTransactionReceipt(): Promise { + return (await this.provider.getTransactionReceipt(this.transactionHash)); + } + + removedEvent(): OrphanFilter { + return createRemovedLogFilter(this); + } +} + + +////////////////////// +// Transaction Receipt + +export interface TransactionReceiptParams { + to: null | string; + from: string; + contractAddress: null | string; + + hash: string; + index: number; + + blockHash: string; + blockNumber: number; + + logsBloom: string; + logs: ReadonlyArray; + + gasUsed: bigint; + cumulativeGasUsed: bigint; + gasPrice?: null | bigint; + effectiveGasPrice?: null | bigint; + + byzantium: boolean; + status: null | number; + root: null | string; +} + +export interface LegacyTransactionReceipt { + byzantium: false; + status: null; + root: string; +} + +export interface ByzantiumTransactionReceipt { + byzantium: true; + status: number; + root: null; +} + +export class TransactionReceipt implements TransactionReceiptParams, Iterable { + readonly provider!: Provider; + + readonly to!: null | string; + readonly from!: string; + readonly contractAddress!: null | string; + + readonly hash!: string; + readonly index!: number; + + readonly blockHash!: string; + readonly blockNumber!: number; + + readonly logsBloom!: string; + + readonly gasUsed!: bigint; + readonly cumulativeGasUsed!: bigint; + readonly gasPrice!: bigint; + + readonly byzantium!: boolean; + readonly status!: null | number; + readonly root!: null | string; + + readonly #logs: ReadonlyArray; + + constructor(tx: TransactionReceiptParams, provider?: null | Provider) { + if (provider == null) { provider = dummyProvider; } + this.#logs = Object.freeze(tx.logs.map((log) => { + if (provider !== log.provider) { + //return log.connect(provider); + throw new Error("provider mismatch"); + } + return log; + })); + + defineProperties(this, { + provider, + + to: tx.to, + from: tx.from, + contractAddress: tx.contractAddress, + + hash: tx.hash, + index: tx.index, + + blockHash: tx.blockHash, + blockNumber: tx.blockNumber, + + logsBloom: tx.logsBloom, + + gasUsed: tx.gasUsed, + cumulativeGasUsed: tx.cumulativeGasUsed, + gasPrice: ((tx.effectiveGasPrice || tx.gasPrice) as bigint), + + byzantium: tx.byzantium, + status: tx.status, + root: tx.root + }); + } + + get logs(): ReadonlyArray { return this.#logs; } + + //connect(provider: Provider): TransactionReceipt { + // return new TransactionReceipt(this, provider); + //} + + toJSON(): any { + const { + to, from, contractAddress, hash, index, blockHash, blockNumber, logsBloom, + logs, byzantium, status, root + } = this; + + return { + _type: "TransactionReceipt", + blockHash, blockNumber, byzantium, contractAddress, + cumulativeGasUsed: toJson(this.cumulativeGasUsed), + from, + gasPrice: toJson(this.gasPrice), + gasUsed: toJson(this.gasUsed), + hash, index, logs, logsBloom, root, status, to + }; + } + + get length(): number { return this.logs.length; } + + [Symbol.iterator](): Iterator { + let index = 0; + return { + next: () => { + if (index < this.length) { + return { value: this.logs[index++], done: false } + } + return { value: undefined, done: true }; + } + }; + } + + get fee(): bigint { + return this.gasUsed * this.gasPrice; + } + + async getBlock(): Promise> { + const block = await this.provider.getBlock(this.blockHash); + if (block == null) { throw new Error("TODO"); } + return block; + } + + async getTransaction(): Promise { + const tx = await this.provider.getTransaction(this.hash); + if (tx == null) { throw new Error("TODO"); } + return tx; + } + + async confirmations(): Promise { + return (await this.provider.getBlockNumber()) - this.blockNumber + 1; + } + + removedEvent(): OrphanFilter { + return createRemovedTransactionFilter(this); + } + + reorderedEvent(other?: TransactionResponse): OrphanFilter { + if (other && !other.isMined()) { + return logger.throwError("unmined 'other' transction cannot be orphaned", "UNSUPPORTED_OPERATION", { + operation: "reorderedEvent(other)" }); + } + return createReorderedTransactionFilter(this, other); + } +} + + +////////////////////// +// Transaction Response + +export interface TransactionResponseParams { + blockNumber: null | number; + blockHash: null | string; + + hash: string; + index: number; + + type: number; + + to: null | string; + from: string; + + nonce: number; + + gasLimit: bigint; + + gasPrice: bigint; + + maxPriorityFeePerGas: null | bigint; + maxFeePerGas: null | bigint; + + data: string; + value: bigint; + chainId: bigint; + + signature: Signature; + + accessList: null | AccessList; +}; + +export interface MinedTransactionResponse extends TransactionResponse { + blockNumber: number; + blockHash: string; + date: Date; +} + +export interface LegacyTransactionResponse extends TransactionResponse { + accessList: null; + maxFeePerGas: null; + maxPriorityFeePerGas: null; +} + +export interface BerlinTransactionResponse extends TransactionResponse { + accessList: AccessList; + maxFeePerGas: null; + maxPriorityFeePerGas: null; +} + +export interface LondonTransactionResponse extends TransactionResponse { + accessList: AccessList; + maxFeePerGas: bigint; + maxPriorityFeePerGas: bigint; +} + +export class TransactionResponse implements TransactionLike, TransactionResponseParams { + readonly provider: Provider; + + readonly blockNumber: null | number; + readonly blockHash: null | string; + + readonly index!: number; + + readonly hash!: string; + + readonly type!: number; + + readonly to!: null | string; + readonly from!: string; + + readonly nonce!: number; + + readonly gasLimit!: bigint; + + readonly gasPrice!: bigint; + + readonly maxPriorityFeePerGas!: null | bigint; + readonly maxFeePerGas!: null | bigint; + + readonly data!: string; + readonly value!: bigint; + readonly chainId!: bigint; + + readonly signature!: Signature; + + readonly accessList!: null | AccessList; + + constructor(tx: TransactionResponseParams, provider?: null | Provider) { + if (provider == null) { provider = dummyProvider; } + this.provider = provider; + + this.blockNumber = (tx.blockNumber != null) ? tx.blockNumber: null; + this.blockHash = (tx.blockHash != null) ? tx.blockHash: null; + + this.hash = tx.hash; + this.index = tx.index; + + this.type = tx.type; + + this.from = tx.from; + this.to = tx.to || null; + + this.gasLimit = tx.gasLimit; + this.nonce = tx.nonce; + this.data = tx.data; + this.value = tx.value; + + this.gasPrice = tx.gasPrice; + this.maxPriorityFeePerGas = (tx.maxPriorityFeePerGas != null) ? tx.maxPriorityFeePerGas: null; + this.maxFeePerGas = (tx.maxFeePerGas != null) ? tx.maxFeePerGas: null; + + this.chainId = tx.chainId; + this.signature = tx.signature; + + this.accessList = (tx.accessList != null) ? tx.accessList: null; + } + + //connect(provider: Provider): TransactionResponse { + // return new TransactionResponse(this, provider); + //} + + toJSON(): any { + const { + blockNumber, blockHash, index, hash, type, to, from, nonce, + data, signature, accessList + } = this; + + return { + _type: "TransactionReceipt", + accessList, blockNumber, blockHash, + chainId: toJson(this.chainId), + data, from, + gasLimit: toJson(this.gasLimit), + gasPrice: toJson(this.gasPrice), + hash, + maxFeePerGas: toJson(this.maxFeePerGas), + maxPriorityFeePerGas: toJson(this.maxPriorityFeePerGas), + nonce, signature, to, index, type, + value: toJson(this.value), + }; + } + + async getBlock(): Promise> { + let blockNumber = this.blockNumber; + if (blockNumber == null) { + const tx = await this.getTransaction(); + if (tx) { blockNumber = tx.blockNumber; } + } + if (blockNumber == null) { return null; } + const block = this.provider.getBlock(blockNumber); + if (block == null) { throw new Error("TODO"); } + return block; + } + + async getTransaction(): Promise { + return this.provider.getTransaction(this.hash); + } + + async wait(confirms?: number): Promise { + return this.provider.waitForTransaction(this.hash, confirms); + } + + isMined(): this is MinedTransactionResponse { + return (this.blockHash != null); + } + + isLegacy(): this is LegacyTransactionResponse { + return (this.type === 0) + } + + isBerlin(): this is BerlinTransactionResponse { + return (this.type === 1); + } + + isLondon(): this is LondonTransactionResponse { + return (this.type === 2); + } + + removedEvent(): OrphanFilter { + if (!this.isMined()) { + return logger.throwError("unmined transaction canot be orphaned", "UNSUPPORTED_OPERATION", { + operation: "removeEvent()" }); + } + return createRemovedTransactionFilter(this); + } + + reorderedEvent(other?: TransactionResponse): OrphanFilter { + if (!this.isMined()) { + return logger.throwError("unmined transaction canot be orphaned", "UNSUPPORTED_OPERATION", { + operation: "removeEvent()" }); + } + if (other && !other.isMined()) { + return logger.throwError("unmined 'other' transaction canot be orphaned", "UNSUPPORTED_OPERATION", { + operation: "removeEvent()" }); + } + return createReorderedTransactionFilter(this, other); + } +} + + +////////////////////// +// OrphanFilter + +export type OrphanFilter = { + orphan: "drop-block", + hash: string, + number: number +} | { + orphan: "drop-transaction", + tx: { hash: string, blockHash: string, blockNumber: number }, + other?: { hash: string, blockHash: string, blockNumber: number } +} | { + orphan: "reorder-transaction", + tx: { hash: string, blockHash: string, blockNumber: number }, + other?: { hash: string, blockHash: string, blockNumber: number } +} | { + orphan: "drop-log", + log: { + transactionHash: string, + blockHash: string, + blockNumber: number, + address: string, + data: string, + topics: ReadonlyArray, + index: number + } +}; + +function createOrphanedBlockFilter(block: { hash: string, number: number }): OrphanFilter { + return { orphan: "drop-block", hash: block.hash, number: block.number }; +} + +function createReorderedTransactionFilter(tx: { hash: string, blockHash: string, blockNumber: number }, other?: { hash: string, blockHash: string, blockNumber: number }): OrphanFilter { + return { orphan: "reorder-transaction", tx, other }; +} + +function createRemovedTransactionFilter(tx: { hash: string, blockHash: string, blockNumber: number }): OrphanFilter { + return { orphan: "drop-transaction", tx }; +} + +function createRemovedLogFilter(log: { blockHash: string, transactionHash: string, blockNumber: number, address: string, data: string, topics: ReadonlyArray, index: number }): OrphanFilter { + return { orphan: "drop-log", log: { + transactionHash: log.transactionHash, + blockHash: log.blockHash, + blockNumber: log.blockNumber, + address: log.address, + data: log.data, + topics: Object.freeze(log.topics.slice()), + index: log.index + } }; +} + +////////////////////// +// EventFilter + +export type TopicFilter = Array>; + +// @TODO: +//export type DeferableTopicFilter = Array | Array>>; + +export interface EventFilter { + address?: AddressLike | Array; + topics?: TopicFilter; +} + +export interface Filter extends EventFilter { + fromBlock?: BlockTag; + toBlock?: BlockTag; +} + +export interface FilterByBlockHash extends EventFilter { + blockHash?: string; +} + + +////////////////////// +// ProviderEvent + +export type ProviderEvent = string | Array> | EventFilter | OrphanFilter; + + +////////////////////// +// Provider + +export interface Provider extends ContractRunner, EventEmitterable, NameResolver { + provider: this; + + + //////////////////// + // State + + /** + * Get the current block number. + */ + getBlockNumber(): Promise; + + /** + * Get the connected [[Network]]. + */ + getNetwork(): Promise>; + + /** + * Get the best guess at the recommended [[FeeData]]. + */ + getFeeData(): Promise; + + + //////////////////// + // Account + + /** + * Get the account balance (in wei) of %%address%%. If %%blockTag%% is specified and + * the node supports archive access, the balance is as of that [[BlockTag]]. + * + * @param {Address | Addressable} address - The account to lookup the balance of + * @param blockTag - The block tag to use for historic archive access. [default: ``"latest"``] + * + * @note On nodes without archive access enabled, the %%blockTag%% may be + * **silently ignored** by the node, which may cause issues if relied on. + */ + getBalance(address: AddressLike, blockTag?: BlockTag): Promise; + + /** + * Get the number of transactions ever sent for %%address%%, which is used as + * the ``nonce`` when sending a transaction. If %%blockTag%% is specified and + * the node supports archive access, the transaction count is as of that [[BlockTag]]. + * + * @param {Address | Addressable} address - The account to lookup the transaction count of + * @param blockTag - The block tag to use for historic archive access. [default: ``"latest"``] + * + * @note On nodes without archive access enabled, the %%blockTag%% may be + * **silently ignored** by the node, which may cause issues if relied on. + */ + getTransactionCount(address: AddressLike, blockTag?: BlockTag): Promise; + + /** + * Get the bytecode for //address//. + * + * @param {Address | Addressable} address - The account to lookup the bytecode of + * @param blockTag - The block tag to use for historic archive access. [default: ``"latest"``] + * + * @note On nodes without archive access enabled, the %%blockTag%% may be + * **silently ignored** by the node, which may cause issues if relied on. + */ + getCode(address: AddressLike, blockTag?: BlockTag): Promise + + /** + * Get the storage slot value for a given //address// and slot //position//. + * + * @param {Address | Addressable} address - The account to lookup the storage of + * @param position - The storage slot to fetch the value of + * @param blockTag - The block tag to use for historic archive access. [default: ``"latest"``] + * + * @note On nodes without archive access enabled, the %%blockTag%% may be + * **silently ignored** by the node, which may cause issues if relied on. + */ + getStorageAt(address: AddressLike, position: BigNumberish, blockTag?: BlockTag): Promise + + + //////////////////// + // Execution + + /** + * Estimates the amount of gas required to executre %%tx%%. + * + * @param tx - The transaction to estimate the gas requirement for + */ + estimateGas(tx: TransactionRequest): Promise; + + // If call fails, throws CALL_EXCEPTION { data: string, error, errorString?, panicReason? } + /** + * Uses call to simulate execution of %%tx%%. + * + * @param tx - The transaction to simulate + */ + call(tx: CallRequest): Promise + + /** + * Broadcasts the %%signedTx%% to the network, adding it to the memory pool + * of any node for which the transaction meets the rebroadcast requirements. + * + * @param signedTx - The transaction to broadcast + */ + broadcastTransaction(signedTx: string): Promise; + + + //////////////////// + // Queries + + getBlock(blockHashOrBlockTag: BlockTag | string): Promise>; + getBlockWithTransactions(blockHashOrBlockTag: BlockTag | string): Promise> + getTransaction(hash: string): Promise; + getTransactionReceipt(hash: string): Promise; + + + //////////////////// + // Bloom-filter Queries + + getLogs(filter: Filter | FilterByBlockHash): Promise>; + + + //////////////////// + // ENS + + resolveName(name: string): Promise; + lookupAddress(address: string): Promise; + + waitForTransaction(hash: string, confirms?: number, timeout?: number): Promise; + waitForBlock(blockTag?: BlockTag): Promise>; +} + + +function fail(): T { + throw new Error("this provider should not be used"); +} + +class DummyProvider implements Provider { + get provider(): this { return this; } + + async getNetwork() { return fail>(); } + async getFeeData() { return fail(); } + + async estimateGas(tx: TransactionRequest) { return fail(); } + async call(tx: CallRequest) { return fail(); } + + async resolveName(name: string) { return fail(); } + + // State + async getBlockNumber() { return fail(); } + + // Account + async getBalance(address: AddressLike, blockTag?: BlockTag) { + return fail(); + } + async getTransactionCount(address: AddressLike, blockTag?: BlockTag) { + return fail(); + } + + async getCode(address: AddressLike, blockTag?: BlockTag) { + return fail(); + } + async getStorageAt(address: AddressLike, position: BigNumberish, blockTag?: BlockTag) { + return fail(); + } + + // Write + async broadcastTransaction(signedTx: string) { return fail(); } + + // Queries + async getBlock(blockHashOrBlockTag: BlockTag | string){ + return fail>(); + } + async getBlockWithTransactions(blockHashOrBlockTag: BlockTag | string) { + return fail>(); + } + async getTransaction(hash: string) { + return fail(); + } + async getTransactionReceipt(hash: string) { + return fail(); + } + + // Bloom-filter Queries + async getLogs(filter: Filter | FilterByBlockHash) { + return fail>(); + } + + // ENS + async lookupAddress(address: string) { + return fail(); + } + + async waitForTransaction(hash: string, confirms?: number, timeout?: number) { + return fail(); + } + + async waitForBlock(blockTag?: BlockTag) { + return fail>(); + } + + // EventEmitterable + async on(event: ProviderEvent, listener: Listener): Promise { return fail(); } + async once(event: ProviderEvent, listener: Listener): Promise { return fail(); } + async emit(event: ProviderEvent, ...args: Array): Promise { return fail(); } + async listenerCount(event?: ProviderEvent): Promise { return fail(); } + async listeners(event?: ProviderEvent): Promise> { return fail(); } + async off(event: ProviderEvent, listener?: Listener): Promise { return fail(); } + async removeAllListeners(event?: ProviderEvent): Promise { return fail(); } + + async addListener(event: ProviderEvent, listener: Listener): Promise { return fail(); } + async removeListener(event: ProviderEvent, listener: Listener): Promise { return fail(); } +} + +/** + * A singleton [[Provider]] instance that can be used as a placeholder. This + * allows API that have a Provider added later to not require a null check. + * + * All operations performed on this [[Provider]] will throw. + */ +export const dummyProvider: Provider = new DummyProvider(); diff --git a/src.ts/providers/signer.ts b/src.ts/providers/signer.ts new file mode 100644 index 000000000..713f45649 --- /dev/null +++ b/src.ts/providers/signer.ts @@ -0,0 +1,149 @@ + +import type { Addressable, NameResolver } from "../address/index.js"; +import type { TypedDataDomain, TypedDataField } from "../hash/index.js"; +import type { TransactionLike } from "../transaction/index.js"; + +import type { ContractRunner } from "./contracts.js"; +import type { BlockTag, CallRequest, Provider, TransactionRequest, TransactionResponse } from "./provider.js"; + +/** + * A Signer represents an account on the Ethereum Blockchain, and is most often + * backed by a private key represented by a mnemonic or residing on a Hardware Wallet. + * + * The API remains abstract though, so that it can deal with more advanced exotic + * Signing entities, such as Smart Contract Wallets or Virtual Wallets (where the + * private key may not be known). + */ +export interface Signer extends Addressable, ContractRunner, NameResolver { + + /** + * The [[Provider]] attached to this Signer (if any). + */ + provider: null | Provider; + + /** + * Returns a new instance of this Signer connected to //provider// or detached + * from any Provider if null. + */ + connect(provider: null | Provider): Signer; + + + //////////////////// + // State + + /** + * Get the [[Address]] of the Signer. + */ + getAddress(): Promise; + + /** + * Gets the next nonce required for this Signer to send a transaction. + * + * @param blockTag - The blocktag to base the transaction count on, keep in mind + * many nodes do not honour this value and silently ignore it [default: ``"latest"``] + */ + getNonce(blockTag?: BlockTag): Promise; + + + //////////////////// + // Preparation + + /** + * Prepares a {@link CallRequest} for calling: + * - resolves ``to`` and ``from`` addresses + * - if ``from`` is specified , check that it matches this Signer + * + * @param tx - The call to prepare + */ + populateCall(tx: CallRequest): Promise>; + + /** + * Prepares a {@link TransactionRequest} for sending to the network by + * populating any missing properties: + * - resolves ``to`` and ``from`` addresses + * - if ``from`` is specified , check that it matches this Signer + * - populates ``nonce`` via ``signer.getNonce("pending")`` + * - populates ``gasLimit`` via ``signer.estimateGas(tx)`` + * - populates ``type`` and relevant fee data for that type (``gasPrice`` + * for legacy transactions, ``maxFeePerGas`` for EIP-1559, etc) + * + * @note Some Signer implementations may skip populating properties that + * are populated downstream; for example JsonRpcSigner defers to the + * node to populate the nonce and fee data. + * + * @param tx - The call to prepare + * @returns The fully prepared {@link TransactionLike} + */ + populateTransaction(tx: TransactionRequest): Promise>; + + + //////////////////// + // Execution + + /** + * Estimates the required gas required to execute //tx// on the Blockchain. This + * will be the expected amount a transaction will require as its ``gasLimit`` + * to successfully run all the necessary computations and store the needed state + * that the transaction intends. + * + * Keep in mind that this is **best efforts**, since the state of the Blockchain + * is in flux, which could affect transaction gas requirements. + * + * @throws UNPREDICTABLE_GAS_LIMIT A transaction that is believed by the node to likely + * fail will throw an error during gas estimation. This could indicate that it + * will actually fail or that the circumstances are simply too complex for the + * node to take into account. In these cases, a manually determined ``gasLimit`` + * will need to be made. + */ + estimateGas(tx: CallRequest): Promise; + + /** + * Evaluates the //tx// by running it against the current Blockchain state. This + * cannot change state and has no cost in ether, as it is effectively simulating + * execution. + * + * This can be used to have the Blockchain perform computations based on its state + * (e.g. running a Contract's getters) or to simulate the effect of a transaction + * before actually performing an operation. + */ + call(tx: CallRequest): Promise; + + /** + * Resolves an [[Address]], ENS Name or [[Addressable]] to an [[Address]]. + */ + resolveName(name: string): Promise; + + + //////////////////// + // Signing + + /** + * Signs %%tx%%, returning the fully signed transaction. This does not populate + * any additional properties within the transaction. + */ + signTransaction(tx: TransactionRequest): Promise; + + /** + * Sends %%tx%% to the Network. The ``signer.populateTransaction(tx)`` is + * called first to ensure all necessary properties for the transaction to be + * valid have been popualted dirst. + */ + sendTransaction(tx: TransactionRequest): Promise; + + /** + * Signers an [[EIP-191]] prefixed personal message. + * + * If the %%message%% is a string, it is signed as UTF-8 encoded bytes. It is **not** + * interpretted as a [[BytesLike]]; so the string ``"0x1234"`` is signed as six + * characters, **not** two bytes. + * + * To sign that example as two bytes, the Uint8Array should be used + * (i.e. ``new Uint8Array([ 0x12, 0x34 ])``). + */ + signMessage(message: string | Uint8Array): Promise; + + /** + * Signs the [[EIP-712]] typed data. + */ + signTypedData(domain: TypedDataDomain, types: Record>, value: Record): Promise; +} diff --git a/src.ts/providers/subscriber-connection.ts b/src.ts/providers/subscriber-connection.ts new file mode 100644 index 000000000..cfaf19144 --- /dev/null +++ b/src.ts/providers/subscriber-connection.ts @@ -0,0 +1,53 @@ + +import type { Subscriber } from "./abstract-provider.js"; +import { logger } from "../utils/logger.js"; + + +//#TODO: Temp +import type { Provider } from "./provider.js"; +export interface ConnectionRpcProvider extends Provider { + //send(method: string, params: Array): Promise; + _subscribe(param: Array, processFunc: (result: any) => void): number; + _unsubscribe(filterId: number): void; +} + +export class BlockConnectionSubscriber implements Subscriber { + #provider: ConnectionRpcProvider; + #blockNumber: number; + + #filterId: null | number; + + constructor(provider: ConnectionRpcProvider) { + this.#provider = provider; + this.#blockNumber = -2; + this.#filterId = null; + } + + start(): void { + this.#filterId = this.#provider._subscribe([ "newHeads" ], (result: any) => { + const blockNumber = logger.getNumber(result.number); + const initial = (this.#blockNumber === -2) ? blockNumber: (this.#blockNumber + 1) + for (let b = initial; b <= blockNumber; b++) { + this.#provider.emit("block", b); + } + this.#blockNumber = blockNumber; + }); + } + + stop(): void { + if (this.#filterId != null) { + this.#provider._unsubscribe(this.#filterId); + this.#filterId = null; + } + } + + pause(dropWhilePaused?: boolean): void { + if (dropWhilePaused) { this.#blockNumber = -2; } + this.stop(); + } + + resume(): void { + this.start(); + } +} + diff --git a/src.ts/providers/subscriber-filterid.ts b/src.ts/providers/subscriber-filterid.ts new file mode 100644 index 000000000..fdd73ecdd --- /dev/null +++ b/src.ts/providers/subscriber-filterid.ts @@ -0,0 +1,133 @@ +import { PollingEventSubscriber } from "./subscriber-polling.js"; + +import type { Frozen } from "../utils/index.js"; + +import type { AbstractProvider, Subscriber } from "./abstract-provider.js"; +import type { Network } from "./network.js"; +import type { EventFilter } from "./provider.js"; +import type { JsonRpcApiProvider } from "./provider-jsonrpc.js"; + + +function copy(obj: any): any { + return JSON.parse(JSON.stringify(obj)); +} + +export class FilterIdSubscriber implements Subscriber { + #provider: JsonRpcApiProvider; + + #filterIdPromise: null | Promise; + #poller: (b: number) => Promise; + + #network: null | Frozen; + + constructor(provider: JsonRpcApiProvider) { + this.#provider = provider; + + this.#filterIdPromise = null; + this.#poller = this.#poll.bind(this); + + this.#network = null; + } + + _subscribe(provider: JsonRpcApiProvider): Promise { + throw new Error("subclasses must override this"); + } + + _emitResults(provider: AbstractProvider, result: Array): Promise { + throw new Error("subclasses must override this"); + } + + _recover(provider: AbstractProvider): Subscriber { + throw new Error("subclasses must override this"); + } + + async #poll(blockNumber: number): Promise { + try { + if (this.#filterIdPromise == null) { + this.#filterIdPromise = this._subscribe(this.#provider); + } + + const filterId = await this.#filterIdPromise; + if (filterId == null) { + this.#provider._recoverSubscriber(this, this._recover(this.#provider)); + return; + } + + const network = await this.#provider.getNetwork(); + if (!this.#network) { this.#network = network; } + + if ((this.#network as Network).chainId !== network.chainId) { + throw new Error("chaid changed"); + } + + const result = await this.#provider.send("eth_getFilterChanges", [ filterId ]); + await this._emitResults(this.#provider, result); + } catch (error) { console.log("@TODO", error); } + + this.#provider.once("block", this.#poller); + } + + #teardown(): void { + const filterIdPromise = this.#filterIdPromise; + if (filterIdPromise) { + this.#filterIdPromise = null; + filterIdPromise.then((filterId) => { + this.#provider.send("eth_uninstallFilter", [ filterId ]); + }); + } + } + + start(): void { this.#poll(-2); } + + stop(): void { + this.#teardown(); + this.#provider.off("block", this.#poller); + } + + pause(dropWhilePaused?: boolean): void { + if (dropWhilePaused){ this.#teardown(); } + this.#provider.off("block", this.#poller); + } + + resume(): void { this.start(); } +} + +export class FilterIdEventSubscriber extends FilterIdSubscriber { + #event: EventFilter; + + constructor(provider: JsonRpcApiProvider, filter: EventFilter) { + super(provider); + this.#event = copy(filter); + } + + _recover(provider: AbstractProvider): Subscriber { + return new PollingEventSubscriber(provider, this.#event); + } + + async _subscribe(provider: JsonRpcApiProvider): Promise { + const filterId = await provider.send("eth_newFilter", [ this.#event ]); + console.log("____SUB", filterId); + return filterId; + } + + async _emitResults(provider: JsonRpcApiProvider, results: Array): Promise { + const network = await provider.getNetwork(); + for (const result of results) { + const log = network.formatter.log(result, provider); + provider.emit(this.#event, log); + } + } +} + +export class FilterIdPendingSubscriber extends FilterIdSubscriber { + async _subscribe(provider: JsonRpcApiProvider): Promise { + return await provider.send("eth_newPendingTransactionFilter", [ ]); + } + + async _emitResults(provider: JsonRpcApiProvider, results: Array): Promise { + const network = await provider.getNetwork(); + for (const result of results) { + provider.emit("pending", network.formatter.hash(result)); + } + } +} diff --git a/src.ts/providers/subscriber-hotswap.ts b/src.ts/providers/subscriber-hotswap.ts new file mode 100644 index 000000000..7a897352d --- /dev/null +++ b/src.ts/providers/subscriber-hotswap.ts @@ -0,0 +1,41 @@ +/* +import { Subscriber } from "./abstract-provider.js"; + +export class HotSwapSubscriber implements Subscriber { + #target?: Subscriber; + + _switchSubscriber(subscriber: Subscriber): void { + this.#target = subscriber; + } + + start(): void { + if (this.#target) { return this.#target.start(); } + return super.start(); + } + + stop(): void { + if (this.#target) { return this.#target.stop(); } + return super.stop(); + } + + pause(dropWhilePaused?: boolean): void { + if (this.#target) { return this.#target.pause(dropWhilePaused); } + return super.pause(dropWhilePaused); + } + + resume(): void { + if (this.#target) { return this.#target.resume(); } + return super.resume(); + } + + set pollingInterval(value: number) { + if (this.#target) { return this.#target.pollingInterval = value; } + return super.pollingInterval = value; + } + + get pollingInterval(): number { + if (this.#target) { return this.#target.pollingInterval; } + return super.pollingInterval; + } +} +*/ diff --git a/src.ts/providers/subscriber-polling.ts b/src.ts/providers/subscriber-polling.ts new file mode 100644 index 000000000..5933f4d61 --- /dev/null +++ b/src.ts/providers/subscriber-polling.ts @@ -0,0 +1,203 @@ +import { isHexString } from "../utils/data.js"; + +import type { AbstractProvider, Subscriber } from "./abstract-provider.js"; +import type { EventFilter, OrphanFilter, ProviderEvent } from "./provider.js"; +import { logger } from "../utils/logger.js"; + +function copy(obj: any): any { + return JSON.parse(JSON.stringify(obj)); +} + +export function getPollingSubscriber(provider: AbstractProvider, event: ProviderEvent): Subscriber { + if (event === "block") { return new PollingBlockSubscriber(provider); } + if (isHexString(event, 32)) { return new PollingTransactionSubscriber(provider, event); } + + return logger.throwError("unsupported polling event", "UNSUPPORTED_OPERATION", { + operation: "getPollingSubscriber", info: { event } + }); +} + +// @TODO: refactor this + +export class PollingBlockSubscriber implements Subscriber{ + #provider: AbstractProvider; + #poller: null | number; + + #interval: number; + + // The most recent block we have scanned for events. The value -2 + // indicates we still need to fetch an initial block number + #blockNumber: number; + + constructor(provider: AbstractProvider) { + this.#provider = provider; + this.#poller = null; + this.#interval = 4000; + + this.#blockNumber = -2; + } + + get pollingInterval(): number { return this.#interval; } + set pollingInterval(value: number) { this.#interval = value; } + + async #poll(): Promise { + const blockNumber = await this.#provider.getBlockNumber(); + if (this.#blockNumber === -2) { + this.#blockNumber = blockNumber; + return; + } + + // @TODO: Put a cap on the maximum number of events per loop? + + if (blockNumber !== this.#blockNumber) { + for (let b = this.#blockNumber + 1; b <= blockNumber; b++) { + this.#provider.emit("block", b); + } + + this.#blockNumber = blockNumber; + } + + this.#poller = this.#provider._setTimeout(this.#poll.bind(this), this.#interval); + } + + start(): void { + if (this.#poller) { throw new Error("subscriber already running"); } + this.#poll(); + this.#poller = this.#provider._setTimeout(this.#poll.bind(this), this.#interval); + } + + stop(): void { + if (!this.#poller) { throw new Error("subscriber not running"); } + this.#provider._clearTimeout(this.#poller); + this.#poller = null; + } + + pause(dropWhilePaused?: boolean): void { + this.stop(); + if (dropWhilePaused) { this.#blockNumber = -2; } + } + + resume(): void { + this.start(); + } +} + +export class OnBlockSubscriber implements Subscriber { + #provider: AbstractProvider; + #poll: (b: number) => void; + + constructor(provider: AbstractProvider) { + this.#provider = provider; + this.#poll = (blockNumber: number) => { + this._poll(blockNumber, this.#provider); + } + } + + async _poll(blockNumber: number, provider: AbstractProvider): Promise { + throw new Error("sub-classes must override this"); + } + + start(): void { + this.#poll(-2); + this.#provider.on("block", this.#poll); + } + + stop(): void { + this.#provider.off("block", this.#poll); + } + + pause(dropWhilePaused?: boolean): void { this.stop(); } + resume(): void { this.start(); } +} + +export class PollingOrphanSubscriber extends OnBlockSubscriber { + #filter: OrphanFilter; + + constructor(provider: AbstractProvider, filter: OrphanFilter) { + super(provider); + this.#filter = copy(filter); + } + + async _poll(blockNumber: number, provider: AbstractProvider): Promise { + throw new Error("@TODO"); + console.log(this.#filter); + } +} + +export class PollingTransactionSubscriber extends OnBlockSubscriber { + #hash: string; + + constructor(provider: AbstractProvider, hash: string) { + super(provider); + this.#hash = hash; + } + + async _poll(blockNumber: number, provider: AbstractProvider): Promise { + const tx = await provider.getTransactionReceipt(this.#hash); + if (tx) { provider.emit(this.#hash, tx); } + } +} + +export class PollingEventSubscriber implements Subscriber { + #provider: AbstractProvider; + #filter: EventFilter; + #poller: (b: number) => void; + + // The most recent block we have scanned for events. The value -2 + // indicates we still need to fetch an initial block number + #blockNumber: number; + + constructor(provider: AbstractProvider, filter: EventFilter) { + this.#provider = provider; + this.#filter = copy(filter); + this.#poller = this.#poll.bind(this); + this.#blockNumber = -2; + } + + async #poll(blockNumber: number): Promise { + // The initial block hasn't been determined yet + if (this.#blockNumber === -2) { return; } + + const filter = copy(this.#filter); + filter.fromBlock = this.#blockNumber + 1; + filter.toBlock = blockNumber; + const logs = await this.#provider.getLogs(filter); + + // No logs could just mean the node has not indexed them yet, + // so we keep a sliding window of 60 blocks to keep scanning + if (logs.length === 0) { + if (this.#blockNumber < blockNumber - 60) { + this.#blockNumber = blockNumber - 60; + } + return; + } + + this.#blockNumber = blockNumber; + + for (const log of logs) { + this.#provider.emit(this.#filter, log); + } + } + + start(): void { + if (this.#blockNumber === -2) { + this.#provider.getBlockNumber().then((blockNumber) => { + this.#blockNumber = blockNumber; + }); + } + this.#provider.on("block", this.#poller); + } + + stop(): void { + this.#provider.off("block", this.#poller); + } + + pause(dropWhilePaused?: boolean): void { + this.stop(); + if (dropWhilePaused) { this.#blockNumber = -2; } + } + + resume(): void { + this.start(); + } +} diff --git a/src.ts/providers/subscriber.ts b/src.ts/providers/subscriber.ts new file mode 100644 index 000000000..6b200387f --- /dev/null +++ b/src.ts/providers/subscriber.ts @@ -0,0 +1,56 @@ + +/* +import { defineProperties } from "@ethersproject/properties"; +export type EventCommon = "block" | "debug" | "blockObject"; + +export type Event = EventCommon | string | { address?: string, topics: Array> } + +export type EventLike = Event | Array; + +export function getTag(eventName: Event): string { + if (typeof(eventName) === "string") { return eventName; } + + if (typeof(eventName) === "object") { + return (eventName.address || "*") + (eventName.topics || []).map((topic) => { + if (typeof(topic) === "string") { return topic; } + return topic.join("|"); + }).join("&"); + } + + throw new Error("FOO"); +} + +export function getEvent(tag: string): Event { +} + +let nextId = 1; + +export class Subscriber { + readonly id!: number; + readonly tag!: string; + + #paused: boolean; + #blockNumber: number; + + constructor(tag: string) { + this.#paused = false; + this.#blockNumber = -1; + defineProperties(this, { id: nextId++, tag }); + } + + get blockNumber(): number { + return this.#blockNumber; + } + _setBlockNumber(blockNumber: number): void { this.#blockNumber = blockNumber; } + + setup(): void { } + teardown(): void { } + + isPaused(): boolean { return this.#paused; } + pause(): void { this.#paused = true; } + resume(): void { this.#paused = false; } + + resubscribeInfo(): string { return this.tag; } + resubscribe(info: string): boolean { return true; } +} +*/ diff --git a/src.ts/providers/ws-browser.ts b/src.ts/providers/ws-browser.ts new file mode 100644 index 000000000..3e9281f4b --- /dev/null +++ b/src.ts/providers/ws-browser.ts @@ -0,0 +1,11 @@ + +function getGlobal(): any { + if (typeof self !== 'undefined') { return self; } + if (typeof window !== 'undefined') { return window; } + if (typeof global !== 'undefined') { return global; } + throw new Error('unable to locate global object'); +}; + +const _WebSocket = getGlobal().WebSocket; + +export { _WebSocket as WebSocket }; diff --git a/src.ts/providers/ws.ts b/src.ts/providers/ws.ts new file mode 100644 index 000000000..09d86da2f --- /dev/null +++ b/src.ts/providers/ws.ts @@ -0,0 +1,3 @@ +export { WebSocket } from "ws"; + + diff --git a/src.ts/thirdparty.d.ts b/src.ts/thirdparty.d.ts new file mode 100644 index 000000000..f35673325 --- /dev/null +++ b/src.ts/thirdparty.d.ts @@ -0,0 +1,16 @@ + + +declare module "ws" { + export class WebSocket { + constructor(...args: Array); + + onopen: null | ((...args: Array) => any); + onmessage: null | ((...args: Array) => any); + onerror: null | ((...args: Array) => any); + + readyState: number; + + send(payload: any): void; + close(code?: number, reason?: string): void; + } +} diff --git a/src.ts/transaction/accesslist.ts b/src.ts/transaction/accesslist.ts new file mode 100644 index 000000000..4d68d389f --- /dev/null +++ b/src.ts/transaction/accesslist.ts @@ -0,0 +1,43 @@ +import { getAddress } from "../address/index.js"; +import { dataLength } from "../utils/index.js"; + +import type { AccessList, AccessListish } from "./index.js"; + + +function accessSetify(addr: string, storageKeys: Array): { address: string,storageKeys: Array } { + return { + address: getAddress(addr), + storageKeys: (storageKeys || []).map((storageKey, index) => { + if (dataLength(storageKey) !== 32) { + //logger.throwArgumentError("invalid access list storageKey", `accessList[${ addr }> + throw new Error(""); + } + return storageKey.toLowerCase(); + }) + }; +} + +export function accessListify(value: AccessListish): AccessList { + if (Array.isArray(value)) { + return (] | { address: string, storageKeys: Array}>>value).map((set, index) => { + if (Array.isArray(set)) { + if (set.length > 2) { + //logger.throwArgumentError("access list expected to be [ address, storageKeys[> + throw new Error(""); + } + return accessSetify(set[0], set[1]) + } + return accessSetify(set.address, set.storageKeys); + }); + } + + const result: Array<{ address: string, storageKeys: Array }> = Object.keys(value).map((addr) => { + const storageKeys: Record = value[addr].reduce((accum, storageKey) => { + accum[storageKey] = true; + return accum; + }, >{ }); + return accessSetify(addr, Object.keys(storageKeys).sort()) + }); + result.sort((a, b) => (a.address.localeCompare(b.address))); + return result; +} diff --git a/src.ts/transaction/address.ts b/src.ts/transaction/address.ts new file mode 100644 index 000000000..06c78c2c0 --- /dev/null +++ b/src.ts/transaction/address.ts @@ -0,0 +1,15 @@ +import { getAddress } from "../address/index.js"; +import { keccak256, SigningKey } from "../crypto/index.js"; + +import type { SignatureLike } from "../crypto/index.js"; +import type { BytesLike } from "../utils/index.js"; + + +export function computeAddress(key: string): string { + const publicKey = SigningKey.computePublicKey(key, false); + return getAddress(keccak256("0x" + publicKey.substring(4)).substring(26)); +} + +export function recoverAddress(digest: BytesLike, signature: SignatureLike): string { + return computeAddress(SigningKey.recoverPublicKey(digest, signature)); +} diff --git a/src.ts/transaction/index.ts b/src.ts/transaction/index.ts new file mode 100644 index 000000000..a0b7ad454 --- /dev/null +++ b/src.ts/transaction/index.ts @@ -0,0 +1,15 @@ + +export type AccessListSet = { address: string, storageKeys: Array }; +export type AccessList = Array; + +// Input allows flexibility in describing an access list +export type AccessListish = AccessList | + Array<[ string, Array ]> | + Record>; + + +export { accessListify } from "./accesslist.js"; +export { computeAddress, recoverAddress } from "./address.js"; +export { Transaction } from "./transaction.js"; + +export type { SignedTransaction, TransactionLike } from "./transaction.js"; diff --git a/src.ts/transaction/transaction.ts b/src.ts/transaction/transaction.ts new file mode 100644 index 000000000..896321086 --- /dev/null +++ b/src.ts/transaction/transaction.ts @@ -0,0 +1,673 @@ + +import { getAddress } from "../address/index.js"; +import { keccak256, Signature } from "../crypto/index.js"; +import { + concat, decodeRlp, encodeRlp, getStore, hexlify, logger, setStore, toArray, zeroPadValue +} from "../utils/index.js"; + +import { accessListify } from "./accesslist.js"; +import { recoverAddress } from "./address.js"; + +import type { BigNumberish, BytesLike, Freezable, Frozen } from "../utils/index.js"; +import type { SignatureLike } from "../crypto/index.js"; + +import type { AccessList, AccessListish } from "./index.js"; + + +const BN_0 = BigInt(0); +const BN_2 = BigInt(2); +const BN_27 = BigInt(27) +const BN_28 = BigInt(28) +const BN_35 = BigInt(35); +const BN_MAX_UINT = BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); + +export interface TransactionLike { + type?: null | number; + + to?: null | A; + from?: null | A; + + nonce?: null | number; + + gasLimit?: null | BigNumberish; + gasPrice?: null | BigNumberish; + + maxPriorityFeePerGas?: null | BigNumberish; + maxFeePerGas?: null | BigNumberish; + + data?: null | string; + value?: null | BigNumberish; + chainId?: null | BigNumberish; + + hash?: null | string; + + signature?: null | SignatureLike; + + accessList?: null | AccessListish; +} + +function handleAddress(value: string): null | string { + if (value === "0x") { return null; } + return getAddress(value); +} + +function handleData(value: string, param: string): string { + try { + return hexlify(value); + } catch (error) { + return logger.throwArgumentError("invalid data", param, value); + } +} + +function handleAccessList(value: any, param: string): AccessList { + try { + return accessListify(value); + } catch (error) { + return logger.throwArgumentError("invalid accessList", param, value); + } +} + +function handleNumber(_value: string, param: string): number { + if (_value === "0x") { return 0; } + return logger.getNumber(_value, param); +} + +function handleUint(_value: string, param: string): bigint { + if (_value === "0x") { return BN_0; } + const value = logger.getBigInt(_value, param); + if (value > BN_MAX_UINT) { logger.throwArgumentError("value exceeds uint size", param, value); } + return value; +} + +function formatNumber(_value: BigNumberish, name: string): Uint8Array { + const value = logger.getBigInt(_value, "value"); + const result = toArray(value); + if (result.length > 32) { + logger.throwArgumentError(`value too large`, `tx.${ name }`, value); + } + return result; +} + +function formatAccessList(value: AccessListish): Array<[ string, Array ]> { + return accessListify(value).map((set) => [ set.address, set.storageKeys ]); +} + +function _parseLegacy(data: Uint8Array): TransactionLike { + const fields: any = decodeRlp(data); + + if (!Array.isArray(fields) || (fields.length !== 9 && fields.length !== 6)) { + return logger.throwArgumentError("invalid field count for legacy transaction", "data", data); + } + + const tx: TransactionLike = { + type: 0, + nonce: handleNumber(fields[0], "nonce"), + gasPrice: handleUint(fields[1], "gasPrice"), + gasLimit: handleUint(fields[2], "gasLimit"), + to: handleAddress(fields[3]), + value: handleUint(fields[4], "value"), + data: handleData(fields[5], "dta"), + chainId: BN_0 + }; + + // Legacy unsigned transaction + if (fields.length === 6) { return tx; } + + const v = handleUint(fields[6], "v"); + const r = handleUint(fields[7], "r"); + const s = handleUint(fields[8], "s"); + + if (r === BN_0 && s === BN_0) { + // EIP-155 unsigned transaction + tx.chainId = v; + + } else { + + // Compute the EIP-155 chain ID (or 0 for legacy) + let chainId = (v - BN_35) / BN_2; + if (chainId < BN_0) { chainId = BN_0; } + tx.chainId = chainId + + // Signed Legacy Transaction + if (chainId === BN_0 && (v < BN_27 || v > BN_28)) { + logger.throwArgumentError("non-canonical legacy v", "v", fields[6]); + } + + tx.signature = Signature.from({ + r: zeroPadValue(fields[7], 32), + s: zeroPadValue(fields[8], 32), + v + }); + + tx.hash = keccak256(data); + } + + return tx; +} + +function _serializeLegacy(tx: Transaction, sig?: Signature): string { + const fields: Array = [ + formatNumber(tx.nonce || 0, "nonce"), + formatNumber(tx.gasPrice || 0, "gasPrice"), + formatNumber(tx.gasLimit || 0, "gasLimit"), + ((tx.to != null) ? getAddress(tx.to): "0x"), + formatNumber(tx.value || 0, "value"), + (tx.data || "0x"), + ]; + + let chainId = BN_0; + if (tx.chainId != null) { + // A chainId was provided; if non-zero we'll use EIP-155 + chainId = logger.getBigInt(tx.chainId, "tx.chainId"); + + // We have a chainId in the tx and an EIP-155 v in the signature, + // make sure they agree with each other + if (sig && sig.networkV != null && sig.legacyChainId !== chainId) { + logger.throwArgumentError("tx.chainId/sig.v mismatch", "sig", sig); + } + + } else if (sig) { + // No chainId provided, but the signature is signing with EIP-155; derive chainId + const legacy = sig.legacyChainId; + if (legacy != null) { chainId = legacy; } + } + + // Requesting an unsigned transaction + if (!sig) { + // We have an EIP-155 transaction (chainId was specified and non-zero) + if (chainId !== BN_0) { + fields.push(toArray(chainId)); + fields.push("0x"); + fields.push("0x"); + } + + return encodeRlp(fields); + } + + // We pushed a chainId and null r, s on for hashing only; remove those + let v = BigInt(27 + sig.yParity); + if (chainId !== BN_0) { + v = Signature.getChainIdV(chainId, sig.v); + } else if (BigInt(sig.v) !== v) { + logger.throwArgumentError("tx.chainId/sig.v mismatch", "sig", sig); + } + + fields.push(toArray(v)); + fields.push(toArray(sig.r)); + fields.push(toArray(sig.s)); + + return encodeRlp(fields); +} + +function _parseEipSignature(tx: TransactionLike, fields: Array, serialize: (tx: TransactionLike) => string): void { + let yParity: number; + try { + yParity = handleNumber(fields[0], "yParity"); + if (yParity !== 0 && yParity !== 1) { throw new Error("bad yParity"); } + } catch (error) { + return logger.throwArgumentError("invalid yParity", "yParity", fields[0]); + } + + const r = zeroPadValue(fields[1], 32); + const s = zeroPadValue(fields[2], 32); + + const signature = Signature.from({ r, s, yParity }); + tx.signature = signature; +} + +function _parseEip1559(data: Uint8Array): TransactionLike { + const fields: any = decodeRlp(logger.getBytes(data).slice(1)); + + if (!Array.isArray(fields) || (fields.length !== 9 && fields.length !== 12)) { + logger.throwArgumentError("invalid field count for transaction type: 2", "data", hexlify(data)); + } + + const maxPriorityFeePerGas = handleUint(fields[2], "maxPriorityFeePerGas"); + const maxFeePerGas = handleUint(fields[3], "maxFeePerGas"); + const tx: TransactionLike = { + type: 2, + chainId: handleUint(fields[0], "chainId"), + nonce: handleNumber(fields[1], "nonce"), + maxPriorityFeePerGas: maxPriorityFeePerGas, + maxFeePerGas: maxFeePerGas, + gasPrice: null, + gasLimit: handleUint(fields[4], "gasLimit"), + to: handleAddress(fields[5]), + value: handleUint(fields[6], "value"), + data: handleData(fields[7], "data"), + accessList: handleAccessList(fields[8], "accessList"), + }; + + // Unsigned EIP-1559 Transaction + if (fields.length === 9) { return tx; } + + tx.hash = keccak256(data); + + _parseEipSignature(tx, fields.slice(9), _serializeEip1559); + + return tx; +} + +function _serializeEip1559(tx: TransactionLike, sig?: Signature): string { + const fields: Array = [ + formatNumber(tx.chainId || 0, "chainId"), + formatNumber(tx.nonce || 0, "nonce"), + formatNumber(tx.maxPriorityFeePerGas || 0, "maxPriorityFeePerGas"), + formatNumber(tx.maxFeePerGas || 0, "maxFeePerGas"), + formatNumber(tx.gasLimit || 0, "gasLimit"), + ((tx.to != null) ? getAddress(tx.to): "0x"), + formatNumber(tx.value || 0, "value"), + (tx.data || "0x"), + (formatAccessList(tx.accessList || [])) + ]; + + if (sig) { + fields.push(formatNumber(sig.yParity, "yParity")); + fields.push(toArray(sig.r)); + fields.push(toArray(sig.s)); + } + + return concat([ "0x02", encodeRlp(fields)]); +} + +function _parseEip2930(data: Uint8Array): TransactionLike { + const fields: any = decodeRlp(logger.getBytes(data).slice(1)); + + if (!Array.isArray(fields) || (fields.length !== 8 && fields.length !== 11)) { + logger.throwArgumentError("invalid field count for transaction type: 1", "data", hexlify(data)); + } + + const tx: TransactionLike = { + type: 1, + chainId: handleUint(fields[0], "chainId"), + nonce: handleNumber(fields[1], "nonce"), + gasPrice: handleUint(fields[2], "gasPrice"), + gasLimit: handleUint(fields[3], "gasLimit"), + to: handleAddress(fields[4]), + value: handleUint(fields[5], "value"), + data: handleData(fields[6], "data"), + accessList: handleAccessList(fields[7], "accessList") + }; + + // Unsigned EIP-2930 Transaction + if (fields.length === 8) { return tx; } + + tx.hash = keccak256(data); + + _parseEipSignature(tx, fields.slice(8), _serializeEip2930); + + return tx; +} + +function _serializeEip2930(tx: TransactionLike, sig?: Signature): string { + const fields: any = [ + formatNumber(tx.chainId || 0, "chainId"), + formatNumber(tx.nonce || 0, "nonce"), + formatNumber(tx.gasPrice || 0, "gasPrice"), + formatNumber(tx.gasLimit || 0, "gasLimit"), + ((tx.to != null) ? getAddress(tx.to): "0x"), + formatNumber(tx.value || 0, "value"), + (tx.data || "0x"), + (formatAccessList(tx.accessList || [])) + ]; + + if (sig) { + fields.push(formatNumber(sig.yParity, "recoveryParam")); + fields.push(toArray(sig.r)); + fields.push(toArray(sig.s)); + } + + return concat([ "0x01", encodeRlp(fields)]); +} + +export interface SignedTransaction extends Transaction { + type: number; + typeName: string; + from: string; + signature: Signature; +} + +export interface LegacyTransaction extends Transaction { + type: 0; + gasPrice: bigint; +} + +export interface BerlinTransaction extends Transaction { + type: 1; + gasPrice: bigint; + accessList: AccessList; +} + +export interface LondonTransaction extends Transaction { + type: 2; + maxFeePerGas: bigint; + maxPriorityFeePerGas: bigint; + accessList: AccessList; +} + +export class Transaction implements Freezable, TransactionLike { + #props: { + type: null | number, + to: null | string, + data: string, + nonce: number, + gasLimit: bigint, + gasPrice: null | bigint, + maxPriorityFeePerGas: null | bigint, + maxFeePerGas: null | bigint, + value: bigint, + chainId: bigint, + sig: null | Signature, + accessList: null | AccessList + }; + + // A type of null indicates the type will be populated automatically + get type(): null | number { return getStore(this.#props, "type"); } + get typeName(): null | string { + switch (this.type) { + case 0: return "legacy"; + case 1: return "eip-2930"; + case 2: return "eip-1559"; + } + + return null; + } + set type(value: null | number | string) { + switch (value) { + case null: + setStore(this.#props, "type", null); + break; + case 0: case "legacy": + setStore(this.#props, "type", 0); + break; + case 1: case "berlin": case "eip-2930": + setStore(this.#props, "type", 1); + break; + case 2: case "london": case "eip-1559": + setStore(this.#props, "type", 2); + break; + default: + throw new Error(`unsupported transaction type`); + } + } + + get to(): null | string { return getStore(this.#props, "to"); } + set to(value: null | string) { + setStore(this.#props, "to", (value == null) ? null: getAddress(value)); + } + + get nonce(): number { return getStore(this.#props, "nonce"); } + set nonce(value: BigNumberish) { setStore(this.#props, "nonce", logger.getNumber(value, "value")); } + + get gasLimit(): bigint { return getStore(this.#props, "gasLimit"); } + set gasLimit(value: BigNumberish) { setStore(this.#props, "gasLimit", logger.getBigInt(value)); } + + get gasPrice(): null | bigint { + const value = getStore(this.#props, "gasPrice"); + if (value == null && (this.type === 0 || this.type === 1)) { return BN_0; } + return value; + } + set gasPrice(value: null | BigNumberish) { + setStore(this.#props, "gasPrice", (value == null) ? null: logger.getBigInt(value, "gasPrice")); + } + + get maxPriorityFeePerGas(): null | bigint { + const value = getStore(this.#props, "maxPriorityFeePerGas"); + if (value == null && this.type === 2) { return BN_0; } + return value; + } + set maxPriorityFeePerGas(value: null | BigNumberish) { + setStore(this.#props, "maxPriorityFeePerGas", (value == null) ? null: logger.getBigInt(value, "maxPriorityFeePerGas")); + } + + get maxFeePerGas(): null | bigint { + const value = getStore(this.#props, "maxFeePerGas"); + if (value == null && this.type === 2) { return BN_0; } + return value; + } + set maxFeePerGas(value: null | BigNumberish) { + setStore(this.#props, "maxFeePerGas", (value == null) ? null: logger.getBigInt(value, "maxFeePerGas")); + } + + get data(): string { return getStore(this.#props, "data"); } + set data(value: BytesLike) { setStore(this.#props, "data", hexlify(value)); } + + get value(): bigint { return getStore(this.#props, "value"); } + set value(value: BigNumberish) { + setStore(this.#props, "value", logger.getBigInt(value, "value")); + } + + get chainId(): bigint { return getStore(this.#props, "chainId"); } + set chainId(value: BigNumberish) { setStore(this.#props, "chainId", logger.getBigInt(value)); } + + get signature(): null | Signature { return getStore(this.#props, "sig") || null; } + set signature(value: null | SignatureLike) { + setStore(this.#props, "sig", (value == null) ? null: Signature.from(value)); + } + + get accessList(): null | AccessList { + const value = getStore(this.#props, "accessList") || null; + if (value == null && (this.type === 1 || this.type === 2)) { return [ ]; } + return value; + } + set accessList(value: null | AccessListish) { + setStore(this.#props, "accessList", (value == null) ? null: accessListify(value)); + } + + constructor() { + this.#props = { + type: null, + to: null, + nonce: 0, + gasLimit: BigInt(0), + gasPrice: null, + maxPriorityFeePerGas: null, + maxFeePerGas: null, + data: "0x", + value: BigInt(0), + chainId: BigInt(0), + sig: null, + accessList: null + }; + } + + get hash(): null | string { + if (this.signature == null) { + throw new Error("cannot hash unsigned transaction; maybe you meant .unsignedHash"); + } + return keccak256(this.serialized); + } + + get unsignedHash(): string { + return keccak256(this.unsignedSerialized); + } + + get from(): null | string { + if (this.signature == null) { return null; } + return recoverAddress(this.unsignedSerialized, this.signature); + } + + get fromPublicKey(): null | string { + if (this.signature == null) { return null; } + // use ecrecover + return ""; + } + + isSigned(): this is SignedTransaction { + return this.signature != null; + } + + get serialized(): string { + if (this.signature == null) { + throw new Error("cannot serialize unsigned transaction; maybe you meant .unsignedSerialized"); + } + + const types = this.inferTypes(); + if (types.length !== 1) { + throw new Error("cannot determine transaction type; specify type manually"); + } + + switch (types[0]) { + case 0: + return _serializeLegacy(this, this.signature); + case 1: + return _serializeEip2930(this, this.signature); + case 2: + return _serializeEip1559(this, this.signature); + } + + throw new Error("unsupported type"); + } + + get unsignedSerialized(): string { + const types = this.inferTypes(); + if (types.length !== 1) { + throw new Error("cannot determine transaction type; specify type manually"); + } + + switch (types[0]) { + case 0: + return _serializeLegacy(this); + case 1: + return _serializeEip2930(this); + case 2: + return _serializeEip1559(this); + } + + throw new Error("unsupported type"); + } + + // Validates properties and lists possible types this transaction adheres to + inferTypes(): Array { + + // Checks that there are no conflicting properties set + const hasGasPrice = this.gasPrice != null; + const hasFee = (this.maxFeePerGas != null || this.maxPriorityFeePerGas != null); + const hasAccessList = (this.accessList != null); + + //if (hasGasPrice && hasFee) { + // throw new Error("transaction cannot have gasPrice and maxFeePerGas"); + //} + + if (this.maxFeePerGas != null && this.maxPriorityFeePerGas != null) { + if (this.maxFeePerGas < this.maxPriorityFeePerGas) { + throw new Error("priorityFee cannot be more than maxFee"); + } + } + + //if (this.type === 2 && hasGasPrice) { + // throw new Error("eip-1559 transaction cannot have gasPrice"); + //} + + if ((this.type === 0 || this.type === 1) && hasFee) { + throw new Error("transaction type cannot have maxFeePerGas or maxPriorityFeePerGas"); + } + + if (this.type === 0 && hasAccessList) { + throw new Error("legacy transaction cannot have accessList"); + } + + const types: Array = [ ]; + + // Explicit type + if (this.type != null) { + types.push(this.type); + + } else { + if (hasFee) { + types.push(2); + } else if (hasGasPrice) { + types.push(1); + if (!hasAccessList) { types.push(0); } + } else if (hasAccessList) { + types.push(1); + types.push(2); + } else { + types.push(0); + types.push(1); + types.push(2); + } + } + + types.sort(); + + return types; + } + + isLegacy(): this is LegacyTransaction { return (this.type === 0); } + isBerlin(): this is BerlinTransaction { return (this.type === 1); } + isLondon(): this is LondonTransaction { return (this.type === 2); } + + clone(): Transaction { + return Transaction.from(this); + } + + freeze(): Frozen { + if (this.#props.sig) { + this.#props.sig = (this.#props.sig.clone().freeze()); + } + + if (this.#props.accessList) { + this.#props.accessList = Object.freeze(this.#props.accessList.map((set) => { + Object.freeze(set.storageKeys); + return Object.freeze(set); + })); + } + + Object.freeze(this.#props); + return this; + } + + isFrozen(): boolean { + return Object.isFrozen(this.#props); + } + + static from(tx: string | TransactionLike): Transaction { + if (typeof(tx) === "string") { + const payload = logger.getBytes(tx); + + if (payload[0] >= 0x7f) { // @TODO: > vs >= ?? + return Transaction.from(_parseLegacy(payload)); + } + + switch(payload[0]) { + case 1: return Transaction.from(_parseEip2930(payload)); + case 2: return Transaction.from(_parseEip1559(payload)); + } + + throw new Error("unsupported transaction type"); + } + + const result = new Transaction(); + if (tx.type != null) { result.type = tx.type; } + if (tx.to != null) { result.to = tx.to; } + if (tx.nonce != null) { result.nonce = tx.nonce; } + if (tx.gasLimit != null) { result.gasLimit = tx.gasLimit; } + if (tx.gasPrice != null) { result.gasPrice = tx.gasPrice; } + if (tx.maxPriorityFeePerGas != null) { result.maxPriorityFeePerGas = tx.maxPriorityFeePerGas; } + if (tx.maxFeePerGas != null) { result.maxFeePerGas = tx.maxFeePerGas; } + if (tx.data != null) { result.data = tx.data; } + if (tx.value != null) { result.value = tx.value; } + if (tx.chainId != null) { result.chainId = tx.chainId; } + if (tx.signature != null) { result.signature = Signature.from(tx.signature); } + if (tx.accessList != null) { result.accessList = tx.accessList; } + + if (tx.hash != null) { + if (result.isSigned()) { + if (result.hash !== tx.hash) { throw new Error("hash mismatch"); } + } else { + throw new Error("unsigned transaction cannot have a hashs"); + } + } + + if (tx.from != null) { + if (result.isSigned()) { + if (result.from.toLowerCase() !== (tx.from || "").toLowerCase()) { throw new Error("from mismatch"); } + } else { + throw new Error("unsigned transaction cannot have a from"); + } + } + + return result; + } +} diff --git a/src.ts/utils/base58.ts b/src.ts/utils/base58.ts new file mode 100644 index 000000000..067385eaa --- /dev/null +++ b/src.ts/utils/base58.ts @@ -0,0 +1,52 @@ + +import { logger } from "./logger.js"; +import { toBigInt, toHex } from "./maths.js"; + +import type { BytesLike } from "./index.js"; + + +const Alphabet = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"; +let Lookup: null | Record = null; + +function getAlpha(letter: string): bigint { + if (Lookup == null) { + Lookup = { }; + for (let i = 0; i < Alphabet.length; i++) { + Lookup[Alphabet[i]] = BigInt(i); + } + } + const result = Lookup[letter]; + if (result == null) { + logger.throwArgumentError(`invalid base58 value`, "letter", letter); + } + return result; +} + + +const BN_0 = BigInt(0); +const BN_58 = BigInt(58); + +/** + * Encode %%value%% as Base58-encoded data. + */ +export function encodeBase58(_value: BytesLike): string { + let value = toBigInt(logger.getBytes(_value)); + let result = ""; + while (value) { + result = Alphabet[Number(value % BN_58)] + result; + value /= BN_58; + } + return result; +} + +/** + * Decode the Base58-encoded %%value%%. + */ +export function decodeBase58(value: string): string { + let result = BN_0; + for (let i = 0; i < value.length; i++) { + result *= BN_58; + result += getAlpha(value[i]); + } + return toHex(result); +} diff --git a/src.ts/utils/base64-browser.ts b/src.ts/utils/base64-browser.ts new file mode 100644 index 000000000..b620b8441 --- /dev/null +++ b/src.ts/utils/base64-browser.ts @@ -0,0 +1,25 @@ + +// utils/base64-browser + +import { logger } from "./logger.js"; + +import type { BytesLike } from "./data.js"; + + +export function decodeBase64(textData: string): Uint8Array { + textData = atob(textData); + const data = new Uint8Array(textData.length); + for (let i = 0; i < textData.length; i++) { + data[i] = textData.charCodeAt(i); + } + return logger.getBytes(data); +} + +export function encodeBase64(_data: BytesLike): string { + const data = logger.getBytes(_data); + let textData = ""; + for (let i = 0; i < data.length; i++) { + textData += String.fromCharCode(data[i]); + } + return btoa(textData); +} diff --git a/src.ts/utils/base64.ts b/src.ts/utils/base64.ts new file mode 100644 index 000000000..96fff281c --- /dev/null +++ b/src.ts/utils/base64.ts @@ -0,0 +1,12 @@ +import { logger } from "./logger.js"; + +import type { BytesLike } from "./data.js"; + + +export function decodeBase64(textData: string): Uint8Array { + return logger.getBytesCopy(Buffer.from(textData, "base64")); +}; + +export function encodeBase64(data: BytesLike): string { + return Buffer.from(logger.getBytes(data)).toString("base64"); +} diff --git a/src.ts/utils/data.ts b/src.ts/utils/data.ts new file mode 100644 index 000000000..dce7d7334 --- /dev/null +++ b/src.ts/utils/data.ts @@ -0,0 +1,84 @@ +import { logger } from "./logger.js"; + +export type BytesLike = string | Uint8Array; + + +export function isHexString(value: any, length?: number | boolean): value is string { + if (typeof(value) !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) { + return false + } + + if (typeof(length) === "number" && value.length !== 2 + 2 * length) { return false; } + if (length === true && (value.length % 2) !== 0) { return false; } + + return true; +} + +export function isBytesLike(value: any): value is BytesLike { + return (isHexString(value, true) || (value instanceof Uint8Array)); +} + +const HexCharacters: string = "0123456789abcdef"; +export function hexlify(data: BytesLike): string { + const bytes = logger.getBytes(data); + + let result = "0x"; + for (let i = 0; i < bytes.length; i++) { + const v = bytes[i]; + result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f]; + } + return result; +} + +export function concat(datas: ReadonlyArray): string { + return "0x" + datas.map((d) => hexlify(d).substring(2)).join(""); +} + +export function dataLength(data: BytesLike): number { + if (isHexString(data, true)) { return (data.length - 2) / 2; } + return logger.getBytes(data).length; +} + +export function dataSlice(data: BytesLike, start?: number, end?: number): string { + const bytes = logger.getBytes(data); + if (end != null && end > bytes.length) { logger.throwError("cannot slice beyond data bounds", "BUFFER_OVERRUN", { + buffer: bytes, length: bytes.length, offset: end + }); } + return hexlify(bytes.slice((start == null) ? 0: start, (end == null) ? bytes.length: end)); +} + +export function stripZerosLeft(data: BytesLike): string { + let bytes = hexlify(data).substring(2); + while (bytes.substring(0, 2) == "00") { bytes = bytes.substring(2); } + return "0x" + bytes; +} + + +function zeroPad(data: BytesLike, length: number, left: boolean): string { + const bytes = logger.getBytes(data); + if (length < bytes.length) { + logger.throwError("padding exceeds data length", "BUFFER_OVERRUN", { + buffer: new Uint8Array(bytes), + length: length, + offset: length + 1 + }); + } + + const result = new Uint8Array(length); + result.fill(0); + if (left) { + result.set(bytes, length - bytes.length); + } else { + result.set(bytes, 0); + } + + return hexlify(result); +} + +export function zeroPadValue(data: BytesLike, length: number): string { + return zeroPad(data, length, true); +} + +export function zeroPadBytes(data: BytesLike, length: number): string { + return zeroPad(data, length, false); +} diff --git a/src.ts/utils/errors.ts b/src.ts/utils/errors.ts new file mode 100644 index 000000000..824c046ae --- /dev/null +++ b/src.ts/utils/errors.ts @@ -0,0 +1,285 @@ +//export type TransactionReceipt { +//} + +export type ErrorSignature = { + r: string; + s: string; + yParity: 0 | 1; + networkV: bigint; +}; + +export type ErrorAccessList = Array<{ address: string, storageKeys: Array }>; + +/* +export interface ErrorTransaction { + type?: number; + + to?: string; + from?: string; + + nonce?: number; + + gasLimit?: bigint; + gasPrice?: bigint; + + maxPriorityFeePerGas?: bigint; + maxFeePerGas?: bigint; + + data?: string; + value?: bigint; + chainId?: bigint; + + hash?: string; + + signature?: ErrorSignature; + + accessList?: ErrorAccessList; +} +*/ + +export interface ErrorFetchRequestWithBody extends ErrorFetchRequest { + body: Readonly; +} + +export interface ErrorFetchRequest { + url: string; + method: string; + headers: Readonly>; + getHeader(key: string): string; + body: null | Readonly; + hasBody(): this is ErrorFetchRequestWithBody; +} + + +export interface ErrorFetchResponseWithBody extends ErrorFetchResponse { + body: Readonly; +} + +export interface ErrorFetchResponse { + statusCode: number; + statusMessage: string; + headers: Readonly>; + getHeader(key: string): string; + body: null | Readonly; + hasBody(): this is ErrorFetchResponseWithBody; +} + + +export type ErrorCode = + + // Generic Errors + "UNKNOWN_ERROR" | "NOT_IMPLEMENTED" | "UNSUPPORTED_OPERATION" | + "NETWORK_ERROR" | "SERVER_ERROR" | "TIMEOUT" | "BAD_DATA" | + "CANCELLED" | + + // Operational Errors + "BUFFER_OVERRUN" | "NUMERIC_FAULT" | + + // Argument Errors + "INVALID_ARGUMENT" | "MISSING_ARGUMENT" | "UNEXPECTED_ARGUMENT" | + "VALUE_MISMATCH" | + + // Blockchain Errors + "CALL_EXCEPTION" | "INSUFFICIENT_FUNDS" | "NONCE_EXPIRED" | + "REPLACEMENT_UNDERPRICED" | "TRANSACTION_REPLACED" | + "UNPREDICTABLE_GAS_LIMIT" | + "UNCONFIGURED_NAME" | "OFFCHAIN_FAULT" | + + // User Interaction + "ACTION_REJECTED" +; + +export interface EthersError extends Error { + code: ErrorCode; +// recover?: (...args: Array) => any; + info?: Record; + error?: Error; +} + +// Generic Errors + +export interface UnknownError extends EthersError<"UNKNOWN_ERROR"> { + [ key: string ]: any; +} + +export interface NotImplementedError extends EthersError<"NOT_IMPLEMENTED"> { + operation: string; +} + +export interface UnsupportedOperationError extends EthersError<"UNSUPPORTED_OPERATION"> { + operation: string; +} + +export interface NetworkError extends EthersError<"NETWORK_ERROR"> { + event: string; +} + +export interface ServerError extends EthersError<"SERVER_ERROR"> { + request: ErrorFetchRequest | string; + response?: ErrorFetchResponse; +} + +export interface TimeoutError extends EthersError<"TIMEOUT"> { + operation: string; + reason: string; + request?: ErrorFetchRequest; +} + +export interface BadDataError extends EthersError<"BAD_DATA"> { + value: any; +} + +export interface CancelledError extends EthersError<"CANCELLED"> { +} + + +// Operational Errors + +export interface BufferOverrunError extends EthersError<"BUFFER_OVERRUN"> { + buffer: Uint8Array; + length: number; + offset: number; +} + +export interface NumericFaultError extends EthersError<"NUMERIC_FAULT"> { + operation: string; + fault: string; + value: any; +} + + +// Argument Errors + +export interface InvalidArgumentError extends EthersError<"INVALID_ARGUMENT"> { + argument: string; + value: any; + info?: Record +} + +export interface MissingArgumentError extends EthersError<"MISSING_ARGUMENT"> { + count: number; + expectedCount: number; +} + +export interface UnexpectedArgumentError extends EthersError<"UNEXPECTED_ARGUMENT"> { + count: number; + expectedCount: number; +} + +//export interface ValueMismatchError extends EthersError { +// count: number; +// expectedCount: number; +//} + + +// Blockchain Errors + +export interface CallExceptionError extends EthersError<"CALL_EXCEPTION"> { + // The revert data + data: string; + + // The transaction that triggered the exception + transaction?: any; + + // The Contract, method and args used during invocation + method?: string; + signature?: string; + args?: ReadonlyArray; + + // The Solidity custom revert error + errorSignature?: string; + errorName?: string; + errorArgs?: ReadonlyArray; + reason?: string; +} + +//export interface ContractCallExceptionError extends CallExceptionError { + // The transaction call +// transaction: any;//ErrorTransaction; +//} + +export interface InsufficientFundsError extends EthersError<"INSUFFICIENT_FUNDS"> { + transaction: any;//ErrorTransaction; +} + +export interface NonceExpiredError extends EthersError<"NONCE_EXPIRED"> { + transaction: any; //ErrorTransaction; +} + +export interface OffchainFaultError extends EthersError<"OFFCHAIN_FAULT"> { + transaction?: any; + reason: string; +} + +export interface ReplacementUnderpricedError extends EthersError<"REPLACEMENT_UNDERPRICED"> { + transaction: any; //ErrorTransaction; +} + +export interface TransactionReplacedError extends EthersError<"TRANSACTION_REPLACED"> { + cancelled: boolean; + reason: "repriced" | "cancelled" | "replaced"; + hash: string; + replacement: any; //TransactionResponse; + receipt: any; //TransactionReceipt; +} + +export interface UnconfiguredNameError extends EthersError<"UNCONFIGURED_NAME"> { + value: string; +} + +export interface UnpredictableGasLimitError extends EthersError<"UNPREDICTABLE_GAS_LIMIT"> { + transaction: any; //ErrorTransaction; +} + +export interface ActionRejectedError extends EthersError<"ACTION_REJECTED"> { + action: string +} + +// Coding; converts an ErrorCode its Typed Error + +export type CodedEthersError = + T extends "UNKNOWN_ERROR" ? UnknownError: + T extends "NOT_IMPLEMENTED" ? NotImplementedError: + T extends "UNSUPPORTED_OPERATION" ? UnsupportedOperationError: + T extends "NETWORK_ERROR" ? NetworkError: + T extends "SERVER_ERROR" ? ServerError: + T extends "TIMEOUT" ? TimeoutError: + T extends "BAD_DATA" ? BadDataError: + T extends "CANCELLED" ? CancelledError: + + T extends "BUFFER_OVERRUN" ? BufferOverrunError: + T extends "NUMERIC_FAULT" ? NumericFaultError: + + T extends "INVALID_ARGUMENT" ? InvalidArgumentError: + T extends "MISSING_ARGUMENT" ? MissingArgumentError: + T extends "UNEXPECTED_ARGUMENT" ? UnexpectedArgumentError: + + T extends "CALL_EXCEPTION" ? CallExceptionError: + T extends "INSUFFICIENT_FUNDS" ? InsufficientFundsError: + T extends "NONCE_EXPIRED" ? NonceExpiredError: + T extends "OFFCHAIN_FAULT" ? OffchainFaultError: + T extends "REPLACEMENT_UNDERPRICED" ? ReplacementUnderpricedError: + T extends "TRANSACTION_REPLACED" ? TransactionReplacedError: + T extends "UNCONFIGURED_NAME" ? UnconfiguredNameError: + T extends "UNPREDICTABLE_GAS_LIMIT" ? UnpredictableGasLimitError: + + T extends "ACTION_REJECTED" ? ActionRejectedError: + + never; + +/** + * try { + * // code.... + * } catch (e) { + * if (isError(e, errors.CALL_EXCEPTION)) { + * console.log(e.data); + * } + * } + */ +export function isError>(error: any, code: K): error is T { + return (error && (error).code === code); +} + +export function isCallException(error: any): error is CallExceptionError { + return isError(error, "CALL_EXCEPTION"); +} diff --git a/src.ts/utils/events.ts b/src.ts/utils/events.ts new file mode 100644 index 000000000..6c2a57e9f --- /dev/null +++ b/src.ts/utils/events.ts @@ -0,0 +1,36 @@ +import { defineProperties } from "./properties.js"; + +export type Listener = (...args: Array) => void; + +export interface EventEmitterable { + on(event: T, listener: Listener): Promise; + once(event: T, listener: Listener): Promise; + emit(event: T, ...args: Array): Promise; + listenerCount(event?: T): Promise; + listeners(event?: T): Promise>; + off(event: T, listener?: Listener): Promise; + removeAllListeners(event?: T): Promise; + + // Alias for "on" + addListener(event: T, listener: Listener): Promise; + + // Alias for "off" + removeListener(event: T, listener: Listener): Promise; +} + +export class EventPayload { + readonly filter!: T; + + readonly emitter!: EventEmitterable; + readonly #listener: null | Listener; + + constructor(emitter: EventEmitterable, listener: null | Listener, filter: T) { + this.#listener = listener; + defineProperties>(this, { emitter, filter }); + } + + async removeListener(): Promise { + if (this.#listener == null) { return; } + await this.emitter.off(this.filter, this.#listener); + } +} diff --git a/src.ts/utils/fetch.ts b/src.ts/utils/fetch.ts new file mode 100644 index 000000000..b0c45bcc6 --- /dev/null +++ b/src.ts/utils/fetch.ts @@ -0,0 +1,657 @@ +import { decodeBase64, encodeBase64 } from "./base64.js"; +import { hexlify } from "./data.js"; +import { assertArgument, logger } from "./logger.js"; +import { defineProperties } from "./properties.js"; +import { toUtf8Bytes, toUtf8String } from "./utf8.js" + +import { getUrl } from "./geturl.js"; + + +export type GetUrlResponse = { + statusCode: number, + statusMessage: string, + headers: Record, + body: null | Uint8Array +}; + +export interface FetchRequestWithBody extends FetchRequest { + body: Uint8Array; +} + +/** + * Called before any network request, allowing updated headers (e.g. Bearer tokens), etc. + */ +export type FetchPreflightFunc = (request: FetchRequest) => Promise; + +/** + * Called on the response, allowing client-based throttling logic or post-processing. + */ +export type FetchProcessFunc = (request: FetchRequest, response: FetchResponse) => Promise; + +/** + * Called prior to each retry; return true to retry, false to abort. + */ +export type FetchRetryFunc = (request: FetchRequest, response: FetchResponse, attempt: number) => Promise; + +/** + * Called on Gateway URLs. + */ +export type FetchGatewayFunc = (url: string, signal?: FetchCancelSignal) => Promise; + +/** + * Used to perform a fetch; use this to override the underlying network + * fetch layer. In NodeJS, the default uses the "http" and "https" libraries + * and in the browser ``fetch`` is used. If you wish to use Axios, this is + * how you would register it. + */ +export type FetchGetUrlFunc = (request: FetchRequest, signal?: FetchCancelSignal) => Promise; + + +const MAX_ATTEMPTS = 12; +const SLOT_INTERVAL = 250; + +// The global FetchGetUrlFunc implementation. +let getUrlFunc: FetchGetUrlFunc = getUrl; + +const reData = new RegExp("^data:([^;:]*)?(;base64)?,(.*)$", "i"); +const reIpfs = new RegExp("^ipfs:/\/(ipfs/)?(.*)$", "i"); + +// If locked, new Gateways cannot be added +let locked = false; + +// https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URLs +async function gatewayData(url: string, signal?: FetchCancelSignal): Promise { + try { + const match = url.match(reData); + if (!match) { throw new Error("invalid data"); } + return new FetchResponse(200, "OK", { + "content-type": (match[1] || "text/plain"), + }, (match[1] ? decodeBase64(match[3]): unpercent(match[3]))); + } catch (error) { + return new FetchResponse(599, "BAD REQUEST (invalid data: URI)", { }, null, new FetchRequest(url)); + } +} + +export function getIpfsGatewayFunc(base: string): FetchGatewayFunc { + async function gatewayIpfs(url: string, signal?: FetchCancelSignal): Promise { + try { + const match = url.match(reIpfs); + if (!match) { throw new Error("invalid link"); } + return new FetchRequest(`${ base }${ match[2] }`); + } catch (error) { + return new FetchResponse(599, "BAD REQUEST (invalid IPFS URI)", { }, null, new FetchRequest(url)); + } + } + + return gatewayIpfs; +} + +const Gateways: Record = { + "data": gatewayData, + "ipfs": getIpfsGatewayFunc("https:/\/gateway.ipfs.io/ipfs/") +}; + +const fetchSignals: WeakMap void> = new WeakMap(); + +export class FetchCancelSignal { + #listeners: Array<() => void>; + #cancelled: boolean; + + constructor(request: FetchRequest) { + this.#listeners = [ ]; + this.#cancelled = false; + + fetchSignals.set(request, () => { + if (this.#cancelled) { return; } + this.#cancelled = true; + + for (const listener of this.#listeners) { + setTimeout(() => { listener(); }, 0); + } + this.#listeners = [ ]; + }); + } + + addListener(listener: () => void): void { + if (this.#cancelled) { + logger.throwError("singal already cancelled", "UNSUPPORTED_OPERATION", { + operation: "fetchCancelSignal.addCancelListener" + }); + } + this.#listeners.push(listener); + } + + get cancelled(): boolean { return this.cancelled; } + + checkSignal(): void { + if (!this.cancelled) { return; } + logger.throwError("cancelled", "CANCELLED", { }); + } +} + +// Check the signal, throwing if it is cancelled +function checkSignal(signal?: FetchCancelSignal): FetchCancelSignal { + if (signal == null) { throw new Error("missing signal; should not happen"); } + signal.checkSignal(); + return signal; +} + +export class FetchRequest implements Iterable<[ key: string, value: string ]> { + #allowInsecure: boolean; + #gzip: boolean; + #headers: Record; + #method: string; + #timeout: number; + #url: string; + + #body?: Uint8Array; + #bodyType?: string; + #creds?: string; + + // Hooks + #preflight?: null | FetchPreflightFunc; + #process?: null | FetchProcessFunc; + #retry?: null | FetchRetryFunc; + + #signal?: FetchCancelSignal; + + // URL + get url(): string { return this.#url; } + set url(url: string) { + this.#url = String(url); + } + + // Body + get body(): null | Uint8Array { + if (this.#body == null) { return null; } + return new Uint8Array(this.#body); + } + set body(body: null | string | Readonly | Readonly) { + if (body == null) { + this.#body = undefined; + this.#bodyType = undefined; + } else if (typeof(body) === "string") { + this.#body = toUtf8Bytes(body); + this.#bodyType = "text/plain"; + } else if (body instanceof Uint8Array) { + this.#body = body; + this.#bodyType = "application/octet-stream"; + } else if (typeof(body) === "object") { + this.#body = toUtf8Bytes(JSON.stringify(body)); + this.#bodyType = "application/json"; + } else { + throw new Error("invalid body"); + } + } + + hasBody(): this is FetchRequestWithBody { + return (this.#body != null); + } + + // Method (default: GET with no body, POST with a body) + get method(): string { + if (this.#method) { return this.#method; } + if (this.hasBody()) { return "POST"; } + return "GET"; + } + set method(method: null | string) { + if (method == null) { method = ""; } + this.#method = String(method).toUpperCase(); + } + + // Headers (automatically fills content-type if not explicitly set) + get headers(): Readonly> { + const headers = Object.assign({ }, this.#headers); + + if (this.#creds) { + headers["authorization"] = `Basic ${ encodeBase64(toUtf8Bytes(this.#creds)) }`; + }; + + if (this.allowGzip) { + headers["accept-encoding"] = "gzip"; + } + + if (headers["content-type"] == null && this.#bodyType) { + headers["content-type"] = this.#bodyType; + } + if (this.body) { headers["content-length"] = String(this.body.length); } + + return Object.freeze(headers); + } + getHeader(key: string): string { + return this.headers[key.toLowerCase()]; + } + setHeader(key: string, value: string | number): void { + this.#headers[String(key).toLowerCase()] = String(value); + } + clearHeaders(): void { + this.#headers = { }; + } + + [Symbol.iterator](): Iterator<[ key: string, value: string ]> { + const headers = this.headers; + const keys = Object.keys(headers); + let index = 0; + return { + next: () => { + if (index < keys.length) { + const key = keys[index++]; + return { + value: [ key, headers[key] ], done: false + } + } + return { value: undefined, done: true }; + } + }; + } + + // Configure an Authorization header + get credentials(): null | string { + return this.#creds || null; + } + setCredentials(username: string, password: string): void { + if (username.match(/:/)) { + logger.throwArgumentError("invalid basic authentication username", "username", "[REDACTED]"); + } + this.#creds = `${ username }:${ password }`; + } + + // Configure the request to allow gzipped responses + get allowGzip(): boolean { + return this.#gzip; + } + set allowGzip(value: boolean) { + this.#gzip = !!value; + } + + // Allow credentials to be sent over an insecure (non-HTTPS) channel + get allowInsecureAuthentication(): boolean { + return !!this.#allowInsecure; + } + set allowInsecureAuthentication(value: boolean) { + this.#allowInsecure = !!value; + } + + // Timeout (milliseconds) + get timeout(): number { return this.#timeout; } + set timeout(timeout: number) { + assertArgument(timeout >= 0, "timeout must be non-zero", "timeout", timeout); + this.#timeout = timeout; + } + + // Preflight called before each request is sent + get preflightFunc(): null | FetchPreflightFunc { + return this.#preflight || null; + } + set preflightFunc(preflight: null | FetchPreflightFunc) { + this.#preflight = preflight; + } + + // Preflight called before each request is sent + get processFunc(): null | FetchProcessFunc { + return this.#process || null; + } + set processFunc(process: null | FetchProcessFunc) { + this.#process = process; + } + + // Preflight called before each request is sent + get retryFunc(): null | FetchRetryFunc { + return this.#retry || null; + } + set retryFunc(retry: null | FetchRetryFunc) { + this.#retry = retry; + } + + constructor(url: string) { + this.#url = String(url); + + this.#allowInsecure = false; + this.#gzip = false; + this.#headers = { }; + this.#method = ""; + this.#timeout = 300; + } + + async #send(attempt: number, expires: number, delay: number, _request: FetchRequest, _response: FetchResponse): Promise { + if (attempt >= MAX_ATTEMPTS) { + return _response.makeServerError("exceeded maximum retry limit"); + } + + if (getTime() > expires) { + return logger.throwError("timeout", "TIMEOUT", { + operation: "request.send", reason: "timeout", request: _request + }); + } + + if (delay > 0) { await wait(delay); } + + let req = this.clone(); + const scheme = (req.url.split(":")[0] || "").toLowerCase(); + + // Process any Gateways + if (scheme in Gateways) { + const result = await Gateways[scheme](req.url, checkSignal(_request.#signal)); + if (result instanceof FetchResponse) { + let response = result; + + if (this.processFunc) { + checkSignal(_request.#signal); + try { + response = await this.processFunc(req, response); + } catch (error: any) { + + // Something went wrong during processing; throw a 5xx server error + if (error.throttle == null || typeof(error.stall) !== "number") { + response.makeServerError("error in post-processing function", error).assertOk(); + } + + // Ignore throttling + } + } + + return response; + } + req = result; + } + + // We have a preflight function; update the request + if (this.preflightFunc) { req = await this.preflightFunc(req); } + + const resp = await getUrlFunc(req, checkSignal(_request.#signal)); + let response = new FetchResponse(resp.statusCode, resp.statusMessage, resp.headers, resp.body, _request); + + if (response.statusCode === 301 || response.statusCode === 302) { + + // Redirect + try { + const location = response.headers.location || ""; + return req.redirect(location).#send(attempt + 1, expires, 0, _request, response); + } catch (error) { } + + // Things won't get any better on another attempt; abort + return response; + + } else if (response.statusCode === 429) { + + // Throttle + if (this.retryFunc == null || (await this.retryFunc(req, response, attempt))) { + const retryAfter = response.headers["retry-after"]; + let delay = SLOT_INTERVAL * Math.trunc(Math.random() * Math.pow(2, attempt)); + if (typeof(retryAfter) === "string" && retryAfter.match(/^[1-9][0-9]*$/)) { + delay = parseInt(retryAfter); + } + return req.clone().#send(attempt + 1, expires, delay, _request, response); + } + } + + if (this.processFunc) { + checkSignal(_request.#signal); + try { + response = await this.processFunc(req, response); + } catch (error: any) { + + // Something went wrong during processing; throw a 5xx server error + if (error.throttle == null || typeof(error.stall) !== "number") { + response.makeServerError("error in post-processing function", error).assertOk(); + } + + // Throttle + let delay = SLOT_INTERVAL * Math.trunc(Math.random() * Math.pow(2, attempt));; + if (error.stall >= 0) { delay = error.stall; } + + return req.clone().#send(attempt + 1, expires, delay, _request, response); + } + } + + return response; + } + + send(): Promise { + if (this.#signal != null) { + return logger.throwError("request already sent", "UNSUPPORTED_OPERATION", { operation: "fetchRequest.send" }); + } + this.#signal = new FetchCancelSignal(this); + return this.#send(0, getTime() + this.timeout, 0, this, new FetchResponse(0, "", { }, null, this)); + } + + cancel(): void { + if (this.#signal == null) { + return logger.throwError("request has not been sent", "UNSUPPORTED_OPERATION", { operation: "fetchRequest.cancel" }); + } + const signal = fetchSignals.get(this); + if (!signal) { throw new Error("missing signal; should not happen"); } + signal(); + } + + /** + * Returns a new [[FetchRequest]] that represents the redirection + * to %%location%%. + */ + redirect(location: string): FetchRequest { + // Redirection; for now we only support absolute locataions + const current = this.url.split(":")[0].toLowerCase(); + const target = location.split(":")[0].toLowerCase(); + + // Don't allow redirecting: + // - non-GET requests + // - downgrading the security (e.g. https => http) + // - to non-HTTP (or non-HTTPS) protocols [this could be relaxed?] + if (this.method !== "GET" || (current === "https" && target === "http") || !location.match(/^https?:/)) { + return logger.throwError(`unsupported redirect`, "UNSUPPORTED_OPERATION", { + operation: `redirect(${ this.method } ${ JSON.stringify(this.url) } => ${ JSON.stringify(location) })` + }); + } + + // Create a copy of this request, with a new URL + const req = new FetchRequest(location); + req.method = "GET"; + req.allowGzip = this.allowGzip; + req.timeout = this.timeout; + req.#headers = Object.assign({ }, this.#headers); + if (this.#body) { req.#body = new Uint8Array(this.#body); } + req.#bodyType = this.#bodyType; + + // Do not forward credentials unless on the same domain; only absolute + //req.allowInsecure = false; + // paths are currently supported; may want a way to specify to forward? + //setStore(req.#props, "creds", getStore(this.#pros, "creds")); + + return req; + } + + clone(): FetchRequest { + const clone = new FetchRequest(this.url); + + // Preserve "default method" (i.e. null) + clone.#method = this.#method; + + // Preserve "default body" with type, copying the Uint8Array is present + if (this.#body) { clone.#body = this.#body; } + clone.#bodyType = this.#bodyType; + + // Preserve "default headers" + clone.#headers = Object.assign({ }, this.#headers); + + // Credentials is readonly, so we copy internally + clone.#creds = this.#creds; + + if (this.allowGzip) { clone.allowGzip = true; } + + clone.timeout = this.timeout; + if (this.allowInsecureAuthentication) { clone.allowInsecureAuthentication = true; } + + clone.#preflight = this.#preflight; + clone.#process = this.#process; + clone.#retry = this.#retry; + + return clone; + } + + static lockConfig(): void { + locked = true; + } + + static getGateway(scheme: string): null | FetchGatewayFunc { + return Gateways[scheme.toLowerCase()] || null; + } + + static registerGateway(scheme: string, func: FetchGatewayFunc): void { + scheme = scheme.toLowerCase(); + if (scheme === "http" || scheme === "https") { + throw new Error(`cannot intercept ${ scheme }; use registerGetUrl`); + } + if (locked) { throw new Error("gateways locked"); } + Gateways[scheme] = func; + } + + static registerGetUrl(getUrl: FetchGetUrlFunc): void { + if (locked) { throw new Error("gateways locked"); } + getUrlFunc = getUrl; + } +} + + +export interface FetchResponseWithBody extends FetchResponse { + body: Readonly; +} + +interface ThrottleError extends Error { + stall: number; + throttle: true; +}; + +export class FetchResponse implements Iterable<[ key: string, value: string ]> { + #statusCode: number; + #statusMessage: string; + #headers: Readonly>; + #body: null | Readonly; + #request: null | FetchRequest; + + #error: { error?: Error, message: string }; + + toString(): string { + return ``; + } + + get statusCode(): number { return this.#statusCode; } + get statusMessage(): string { return this.#statusMessage; } + get headers() { return this.#headers; } + get body(): null | Readonly { + return (this.#body == null) ? null: new Uint8Array(this.#body); + } + get bodyText(): string { + try { + return (this.#body == null) ? "": toUtf8String(this.#body); + } catch (error) { + return logger.throwError("response body is not valid UTF-8 data", "UNSUPPORTED_OPERATION", { + operation: "bodyText", info: { response: this } + }); + } + } + get bodyJson(): any { + try { + return JSON.parse(this.bodyText); + } catch (error) { + return logger.throwError("response body is not valid JSON", "UNSUPPORTED_OPERATION", { + operation: "bodyJson", info: { response: this } + }); + } + } + + [Symbol.iterator](): Iterator<[ key: string, value: string ]> { + const headers = this.headers; + const keys = Object.keys(headers); + let index = 0; + return { + next: () => { + if (index < keys.length) { + const key = keys[index++]; + return { + value: [ key, headers[key] ], done: false + } + } + return { value: undefined, done: true }; + } + }; + } + + constructor(statusCode: number, statusMessage: string, headers: Readonly>, body: null | Uint8Array, request?: FetchRequest) { + this.#statusCode = statusCode; + this.#statusMessage = statusMessage; + this.#headers = Object.freeze(Object.assign({ }, Object.keys(headers).reduce((accum, k) => { + accum[k.toLowerCase()] = String(headers[k]); + return accum; + }, >{ }))); + this.#body = ((body == null) ? null: new Uint8Array(body)); + this.#request = (request || null); + + this.#error = { message: "" }; + } + + makeServerError(message?: string, error?: Error): FetchResponse { + let statusMessage: string; + if (!message) { + message = `${ this.statusCode } ${ this.statusMessage }`; + statusMessage = `CLIENT ESCALATED SERVER ERROR (${ message })`; + } else { + statusMessage = `CLIENT ESCALATED SERVER ERROR (${ this.statusCode } ${ this.statusMessage }; ${ message })`; + } + const response = new FetchResponse(599, statusMessage, this.headers, + this.body, this.#request || undefined); + response.#error = { message, error }; + return response; + } + + throwThrottleError(message?: string, stall?: number): never { + if (stall == null) { + stall = -1; + } else if (typeof(stall) !== "number" || !Number.isInteger(stall) || stall < 0) { + return logger.throwArgumentError("invalid stall timeout", "stall", stall); + } + + const error = new Error(message || "throttling requests"); + + defineProperties(error, { stall, throttle: true }); + + throw error; + } + + getHeader(key: string): string { + return this.headers[key.toLowerCase()]; + } + + hasBody(): this is FetchResponseWithBody { + return (this.#body != null); + } + + get request(): null | FetchRequest { return this.#request; } + + ok(): boolean { + return (this.#error.message === "" && this.statusCode >= 200 && this.statusCode < 300); + } + + assertOk(): void { + if (this.ok()) { return; } + let { message, error } = this.#error; + if (message === "") { + message = `server response ${ this.statusCode } ${ this.statusMessage }`; + } + logger.throwError(message, "SERVER_ERROR", { + request: (this.request || "unknown request"), response: this, error + }); + } +} + + +function getTime(): number { return (new Date()).getTime(); } + +function unpercent(value: string): Uint8Array { + return toUtf8Bytes(value.replace(/%([0-9a-f][0-9a-f])/gi, (all, code) => { + return String.fromCharCode(parseInt(code, 16)); + })); +} + +function wait(delay: number): Promise { + return new Promise((resolve) => setTimeout(resolve, delay)); +} diff --git a/src.ts/utils/fixednumber.ts b/src.ts/utils/fixednumber.ts new file mode 100644 index 000000000..ee3c24571 --- /dev/null +++ b/src.ts/utils/fixednumber.ts @@ -0,0 +1,396 @@ +import { logger } from "./logger.js"; +import { fromTwos, toBigInt, toHex, toTwos } from "./maths.js"; + +import type { BigNumberish, BytesLike, Numeric } from "./index.js"; + + +const _constructorGuard = { }; + +const NegativeOne = BigInt(-1); + +function throwFault(message: string, fault: string, operation: string, value?: any): never { + const params: any = { fault: fault, operation: operation }; + if (value !== undefined) { params.value = value; } + return logger.throwError(message, "NUMERIC_FAULT", params); +} + +// Constant to pull zeros from for multipliers +let zeros = "0"; +while (zeros.length < 256) { zeros += zeros; } + +// Returns a string "1" followed by decimal "0"s +function getMultiplier(decimals: number): bigint { + + if (typeof(decimals) !== "number" || decimals < 0 || decimals > 256 || decimals % 1 ) { + logger.throwArgumentError("invalid decimal length", "decimals", decimals); + } + + return BigInt("1" + zeros.substring(0, decimals)); +} + +export function formatFixed(_value: BigNumberish, _decimals?: Numeric): string { + if (_decimals == null) { _decimals = 18; } + + let value = logger.getBigInt(_value, "value"); + const decimals = logger.getNumber(_decimals, "decimals"); + + const multiplier = getMultiplier(decimals); + const multiplierStr = String(multiplier); + + const negative = (value < 0); + if (negative) { value *= NegativeOne; } + + let fraction = String(value % multiplier); + + // Make sure there are enough place-holders + while (fraction.length < multiplierStr.length - 1) { fraction = "0" + fraction; } + + // Strip training 0 + while (fraction.length > 1 && fraction.substring(fraction.length - 1) === "0") { + fraction = fraction.substring(0, fraction.length - 1); + } + + let result = String(value / multiplier); + if (multiplierStr.length !== 1) { result += "." + fraction; } + + if (negative) { result = "-" + result; } + + return result; +} + +export function parseFixed(value: string, _decimals: Numeric): bigint { + if (_decimals == null) { _decimals = 18; } + const decimals = logger.getNumber(_decimals, "decimals"); + + const multiplier = getMultiplier(decimals); + + if (typeof(value) !== "string" || !value.match(/^-?[0-9.]+$/)) { + logger.throwArgumentError("invalid decimal value", "value", value); + } + + // Is it negative? + const negative = (value.substring(0, 1) === "-"); + if (negative) { value = value.substring(1); } + + if (value === ".") { + logger.throwArgumentError("missing value", "value", value); + } + + // Split it into a whole and fractional part + const comps = value.split("."); + if (comps.length > 2) { + logger.throwArgumentError("too many decimal points", "value", value); + } + + let whole = (comps[0] || "0"), fraction = (comps[1] || "0"); + + // Trim trialing zeros + while (fraction[fraction.length - 1] === "0") { + fraction = fraction.substring(0, fraction.length - 1); + } + + // Check the fraction doesn't exceed our decimals size + if (fraction.length > String(multiplier).length - 1) { + throwFault("fractional component exceeds decimals", "underflow", "parseFixed"); + } + + // If decimals is 0, we have an empty string for fraction + if (fraction === "") { fraction = "0"; } + + // Fully pad the string with zeros to get to wei + while (fraction.length < String(multiplier).length - 1) { fraction += "0"; } + + const wholeValue = BigInt(whole); + const fractionValue = BigInt(fraction); + + let wei = (wholeValue * multiplier) + fractionValue; + + if (negative) { wei *= NegativeOne; } + + return wei; +} + + +export class FixedFormat { + readonly signed: boolean; + readonly width: number; + readonly decimals: number; + readonly name: string; + + readonly _multiplier: bigint; + + constructor(constructorGuard: any, signed: boolean, width: number, decimals: number) { + if (constructorGuard !== _constructorGuard) { + logger.throwError("cannot use FixedFormat constructor; use FixedFormat.from", "UNSUPPORTED_OPERATION", { + operation: "new FixedFormat" + }); + } + + this.signed = signed; + this.width = width; + this.decimals = decimals; + + this.name = (signed ? "": "u") + "fixed" + String(width) + "x" + String(decimals); + + this._multiplier = getMultiplier(decimals); + + Object.freeze(this); + } + + static from(value: any): FixedFormat { + if (value instanceof FixedFormat) { return value; } + + if (typeof(value) === "number") { + value = `fixed128x${value}` + } + + let signed = true; + let width = 128; + let decimals = 18; + + if (typeof(value) === "string") { + if (value === "fixed") { + // defaults... + } else if (value === "ufixed") { + signed = false; + } else { + const match = value.match(/^(u?)fixed([0-9]+)x([0-9]+)$/); + if (!match) { + return logger.throwArgumentError("invalid fixed format", "format", value); + } + signed = (match[1] !== "u"); + width = parseInt(match[2]); + decimals = parseInt(match[3]); + } + } else if (value) { + const check = (key: string, type: string, defaultValue: any): any => { + if (value[key] == null) { return defaultValue; } + if (typeof(value[key]) !== type) { + logger.throwArgumentError("invalid fixed format (" + key + " not " + type +")", "format." + key, value[key]); + } + return value[key]; + } + signed = check("signed", "boolean", signed); + width = check("width", "number", width); + decimals = check("decimals", "number", decimals); + } + + if (width % 8) { + logger.throwArgumentError("invalid fixed format width (not byte aligned)", "format.width", width); + } + + if (decimals > 80) { + logger.throwArgumentError("invalid fixed format (decimals too large)", "format.decimals", decimals); + } + + return new FixedFormat(_constructorGuard, signed, width, decimals); + } +} + +export class FixedNumber { + readonly format: FixedFormat; + + readonly _isFixedNumber: boolean; + + //#hex: string; + #value: string; + + constructor(constructorGuard: any, hex: string, value: string, format?: FixedFormat) { + if (constructorGuard !== _constructorGuard) { + logger.throwError("cannot use FixedNumber constructor; use FixedNumber.from", "UNSUPPORTED_OPERATION", { + operation: "new FixedFormat" + }); + } + + this.format = FixedFormat.from(format); + //this.#hex = hex; + this.#value = value; + + this._isFixedNumber = true; + + Object.freeze(this); + } + + #checkFormat(other: FixedNumber): void { + if (this.format.name !== other.format.name) { + logger.throwArgumentError("incompatible format; use fixedNumber.toFormat", "other", other); + } + } + + addUnsafe(other: FixedNumber): FixedNumber { + this.#checkFormat(other); + const a = parseFixed(this.#value, this.format.decimals); + const b = parseFixed(other.#value, other.format.decimals); + return FixedNumber.fromValue(a + b, this.format.decimals, this.format); + } + + subUnsafe(other: FixedNumber): FixedNumber { + this.#checkFormat(other); + const a = parseFixed(this.#value, this.format.decimals); + const b = parseFixed(other.#value, other.format.decimals); + return FixedNumber.fromValue(a - b, this.format.decimals, this.format); + } + + mulUnsafe(other: FixedNumber): FixedNumber { + this.#checkFormat(other); + const a = parseFixed(this.#value, this.format.decimals); + const b = parseFixed(other.#value, other.format.decimals); + return FixedNumber.fromValue((a * b) / this.format._multiplier, this.format.decimals, this.format); + } + + divUnsafe(other: FixedNumber): FixedNumber { + this.#checkFormat(other); + const a = parseFixed(this.#value, this.format.decimals); + const b = parseFixed(other.#value, other.format.decimals); + return FixedNumber.fromValue((a * this.format._multiplier) / b, this.format.decimals, this.format); + } + + floor(): FixedNumber { + const comps = this.toString().split("."); + if (comps.length === 1) { comps.push("0"); } + + let result = FixedNumber.from(comps[0], this.format); + + const hasFraction = !comps[1].match(/^(0*)$/); + if (this.isNegative() && hasFraction) { + result = result.subUnsafe(ONE.toFormat(result.format)); + } + + return result; + } + + ceiling(): FixedNumber { + const comps = this.toString().split("."); + if (comps.length === 1) { comps.push("0"); } + + let result = FixedNumber.from(comps[0], this.format); + + const hasFraction = !comps[1].match(/^(0*)$/); + if (!this.isNegative() && hasFraction) { + result = result.addUnsafe(ONE.toFormat(result.format)); + } + + return result; + } + + // @TODO: Support other rounding algorithms + round(decimals?: number): FixedNumber { + if (decimals == null) { decimals = 0; } + + // If we are already in range, we're done + const comps = this.toString().split("."); + if (comps.length === 1) { comps.push("0"); } + + if (decimals < 0 || decimals > 80 || (decimals % 1)) { + logger.throwArgumentError("invalid decimal count", "decimals", decimals); + } + + if (comps[1].length <= decimals) { return this; } + + const factor = FixedNumber.from("1" + zeros.substring(0, decimals), this.format); + const bump = BUMP.toFormat(this.format); + + return this.mulUnsafe(factor).addUnsafe(bump).floor().divUnsafe(factor); + } + + isZero(): boolean { + return (this.#value === "0.0" || this.#value === "0"); + } + + isNegative(): boolean { + return (this.#value[0] === "-"); + } + + toString(): string { return this.#value; } + + toHexString(_width: Numeric): string { + throw new Error("TODO"); + /* + return toHex(); + if (width == null) { return this.#hex; } + + const width = logger.getNumeric(_width); + if (width % 8) { logger.throwArgumentError("invalid byte width", "width", width); } + + const hex = BigNumber.from(this.#hex).fromTwos(this.format.width).toTwos(width).toHexString(); + return zeroPadLeft(hex, width / 8); + */ + } + + toUnsafeFloat(): number { return parseFloat(this.toString()); } + + toFormat(format: FixedFormat | string): FixedNumber { + return FixedNumber.fromString(this.#value, format); + } + + + static fromValue(value: BigNumberish, decimals = 0, format: FixedFormat | string | number = "fixed"): FixedNumber { + return FixedNumber.fromString(formatFixed(value, decimals), FixedFormat.from(format)); + } + + + static fromString(value: string, format: FixedFormat | string | number = "fixed"): FixedNumber { + const fixedFormat = FixedFormat.from(format); + const numeric = parseFixed(value, fixedFormat.decimals); + + if (!fixedFormat.signed && numeric < 0) { + throwFault("unsigned value cannot be negative", "overflow", "value", value); + } + + const hex = (function() { + if (fixedFormat.signed) { + return toHex(toTwos(numeric, fixedFormat.width)); + } + return toHex(numeric, fixedFormat.width / 8); + })(); + + const decimal = formatFixed(numeric, fixedFormat.decimals); + + return new FixedNumber(_constructorGuard, hex, decimal, fixedFormat); + } + + static fromBytes(_value: BytesLike, format: FixedFormat | string | number = "fixed"): FixedNumber { + const value = logger.getBytes(_value, "value"); + const fixedFormat = FixedFormat.from(format); + + if (value.length > fixedFormat.width / 8) { + throw new Error("overflow"); + } + + let numeric = toBigInt(value); + if (fixedFormat.signed) { numeric = fromTwos(numeric, fixedFormat.width); } + + const hex = toHex(toTwos(numeric, (fixedFormat.signed ? 0: 1) + fixedFormat.width)); + const decimal = formatFixed(numeric, fixedFormat.decimals); + + return new FixedNumber(_constructorGuard, hex, decimal, fixedFormat); + } + + static from(value: any, format?: FixedFormat | string | number) { + if (typeof(value) === "string") { + return FixedNumber.fromString(value, format); + } + + if (value instanceof Uint8Array) { + return FixedNumber.fromBytes(value, format); + } + + try { + return FixedNumber.fromValue(value, 0, format); + } catch (error: any) { + // Allow NUMERIC_FAULT to bubble up + if (error.code !== "INVALID_ARGUMENT") { + throw error; + } + } + + return logger.throwArgumentError("invalid FixedNumber value", "value", value); + } + + static isFixedNumber(value: any): value is FixedNumber { + return !!(value && value._isFixedNumber); + } +} + +const ONE = FixedNumber.from(1); +const BUMP = FixedNumber.from("0.5"); diff --git a/src.ts/utils/geturl-browser.ts b/src.ts/utils/geturl-browser.ts new file mode 100644 index 000000000..3c8b0dadf --- /dev/null +++ b/src.ts/utils/geturl-browser.ts @@ -0,0 +1,76 @@ +import { logger } from "./logger.js"; + +import type { FetchRequest, FetchCancelSignal, GetUrlResponse } from "./fetch.js"; + + +declare global { + class Headers { + constructor(values: Array<[ string, string ]>); + forEach(func: (v: string, k: string) => void): void; + } + + class Response { + status: number; + statusText: string; + headers: Headers; + arrayBuffer(): Promise; + } + + type FetchInit = { + method?: string, + headers?: Headers, + body?: Uint8Array + }; + + function fetch(url: string, init: FetchInit): Promise; +} + +// @TODO: timeout is completely ignored; start a Promise.any with a reject? + +export async function getUrl(req: FetchRequest, _signal?: FetchCancelSignal): Promise { + const protocol = req.url.split(":")[0].toLowerCase(); + + if (protocol !== "http" && protocol !== "https") { + logger.throwError(`unsupported protocol ${ protocol }`, "UNSUPPORTED_OPERATION", { + info: { protocol }, + operation: "request" + }); + } + + if (req.credentials && !req.allowInsecureAuthentication) { + logger.throwError("insecure authorized connections unsupported", "UNSUPPORTED_OPERATION", { + operation: "request" + }); + } + + let signal: undefined | AbortSignal = undefined; + if (_signal) { + const controller = new AbortController(); + signal = controller.signal; + _signal.addListener(() => { controller.abort(); }); + } + + const init = { + method: req.method, + headers: new Headers(Array.from(req)), + body: req.body || undefined, + signal + }; + + const resp = await fetch(req.url, init); + + const headers: Record = { }; + resp.headers.forEach((value, key) => { + headers[key.toLowerCase()] = value; + }); + + const respBody = await resp.arrayBuffer(); + const body = (respBody == null) ? null: new Uint8Array(respBody); + + return { + statusCode: resp.status, + statusMessage: resp.statusText, + headers, body + }; +} + diff --git a/src.ts/utils/geturl.ts b/src.ts/utils/geturl.ts new file mode 100644 index 000000000..b87f206db --- /dev/null +++ b/src.ts/utils/geturl.ts @@ -0,0 +1,97 @@ +import http from "http"; +import https from "https"; +import { gunzipSync } from "zlib"; + +import { logger } from "./logger.js"; + +import type { FetchRequest, FetchCancelSignal, GetUrlResponse } from "./fetch.js"; + + +export async function getUrl(req: FetchRequest, signal?: FetchCancelSignal): Promise { + + const protocol = req.url.split(":")[0].toLowerCase(); + + if (protocol !== "http" && protocol !== "https") { + logger.throwError(`unsupported protocol ${ protocol }`, "UNSUPPORTED_OPERATION", { + info: { protocol }, + operation: "request" + }); + } + + if (req.credentials && !req.allowInsecureAuthentication) { + logger.throwError("insecure authorized connections unsupported", "UNSUPPORTED_OPERATION", { + operation: "request" + }); + } + + const method = req.method; + const headers = Object.assign({ }, req.headers); + + const options: any = { method, headers }; + + const request = ((protocol === "http") ? http: https).request(req.url, options); + + request.setTimeout(req.timeout); + + const body = req.body; + if (body) { request.write(Buffer.from(body)); } + + request.end(); + + return new Promise((resolve, reject) => { + // @TODO: Node 15 added AbortSignal; once we drop support for + // Node14, we can add that in here too + + request.once("response", (resp: http.IncomingMessage) => { + const statusCode = resp.statusCode || 0; + const statusMessage = resp.statusMessage || ""; + const headers = Object.keys(resp.headers || {}).reduce((accum, name) => { + let value = resp.headers[name] || ""; + if (Array.isArray(value)) { + value = value.join(", "); + } + accum[name] = value; + return accum; + }, <{ [ name: string ]: string }>{ }); + + let body: null | Uint8Array = null; + //resp.setEncoding("utf8"); + + resp.on("data", (chunk: Uint8Array) => { + if (signal) { + try { + signal.checkSignal(); + } catch (error) { + return reject(error); + } + } + + if (body == null) { + body = chunk; + } else { + const newBody = new Uint8Array(body.length + chunk.length); + newBody.set(body, 0); + newBody.set(chunk, body.length); + body = newBody; + } + }); + + resp.on("end", () => { + if (headers["content-encoding"] === "gzip" && body) { + body = logger.getBytes(gunzipSync(body)); + } + + resolve({ statusCode, statusMessage, headers, body }); + }); + + resp.on("error", (error) => { + //@TODO: Should this just return nornal response with a server error? + (error).response = { statusCode, statusMessage, headers, body }; + reject(error); + }); + }); + + request.on("error", (error) => { reject(error); }); + }); +} + diff --git a/src.ts/utils/index.ts b/src.ts/utils/index.ts new file mode 100644 index 000000000..5ba084fec --- /dev/null +++ b/src.ts/utils/index.ts @@ -0,0 +1,99 @@ + +//// + +export interface Freezable { + clone(): T; + freeze(): Frozen; + isFrozen(): boolean; +} + +export type Frozen = Readonly<{ + [ P in keyof T ]: T[P] extends (...args: Array) => any ? T[P]: + T[P] extends Freezable ? Frozen: + Readonly; +}>; + + +export { decodeBase58, encodeBase58 } from "./base58.js"; + +export { decodeBase64, encodeBase64 } from "./base64.js"; + +export { + isHexString, isBytesLike, hexlify, concat, dataLength, dataSlice, + stripZerosLeft, zeroPadValue, zeroPadBytes +} from "./data.js"; + +export { isCallException, isError } from "./errors.js" + +export { EventPayload } from "./events.js"; + +export { FetchRequest, FetchResponse } from "./fetch.js"; + +export { FixedFormat, FixedNumber, formatFixed, parseFixed } from "./fixednumber.js" + +export { assertArgument, Logger, logger } from "./logger.js"; + +export { + fromTwos, toTwos, mask, + toBigInt, toNumber, toHex, toArray, toQuantity +} from "./maths.js"; + +export { resolveProperties, defineReadOnly, defineProperties} from "./properties.js"; + +export { decodeRlp } from "./rlp-decode.js"; +export { encodeRlp } from "./rlp-encode.js"; + +export { getStore, setStore} from "./storage.js"; + +export { formatEther, parseEther, formatUnits, parseUnits } from "./units.js"; + +export { + _toEscapedUtf8String, + toUtf8Bytes, + toUtf8CodePoints, + toUtf8String, + + Utf8ErrorFuncs, +} from "./utf8.js"; + + +///////////////////////////// +// Types + +export type { BytesLike } from "./data.js"; + +export type { + + ErrorSignature, ErrorFetchRequestWithBody, ErrorFetchRequest, + ErrorFetchResponseWithBody, ErrorFetchResponse, + + ErrorCode, + + EthersError, UnknownError, NotImplementedError, UnsupportedOperationError, NetworkError, + ServerError, TimeoutError, BadDataError, CancelledError, BufferOverrunError, + NumericFaultError, InvalidArgumentError, MissingArgumentError, UnexpectedArgumentError, + CallExceptionError, InsufficientFundsError, NonceExpiredError, OffchainFaultError, + ReplacementUnderpricedError, TransactionReplacedError, UnconfiguredNameError, + UnpredictableGasLimitError, ActionRejectedError, + + CodedEthersError +} from "./errors.js" + +export type { EventEmitterable, Listener } from "./events.js"; + +export type { + GetUrlResponse, + FetchRequestWithBody, FetchResponseWithBody, + FetchPreflightFunc, FetchProcessFunc, FetchRetryFunc, + FetchGatewayFunc, FetchGetUrlFunc +} from "./fetch.js"; + +export { BigNumberish, Numeric } from "./maths.js"; + +export type { RlpStructuredData } from "./rlp.js"; + +export type { + Utf8ErrorFunc, + UnicodeNormalizationForm, + Utf8ErrorReason +} from "./utf8.js"; diff --git a/src.ts/utils/logger.ts b/src.ts/utils/logger.ts new file mode 100644 index 000000000..ec9fba1fb --- /dev/null +++ b/src.ts/utils/logger.ts @@ -0,0 +1,254 @@ +import { version } from "../_version.js"; + +import type { BigNumberish, BytesLike } from "./index.js"; + +import type { CodedEthersError, ErrorCode } from "./errors.js"; + + +export type ErrorInfo = Omit; + +export type LogLevel = "debug" | "info" | "warning" | "error" | "off"; + +const LogLevels: Array = [ "debug", "info", "warning", "error", "off" ]; + +const _normalizeForms = ["NFD", "NFC", "NFKD", "NFKC"].reduce((accum, form) => { + try { + // General test for normalize + /* c8 ignore start */ + if ("test".normalize(form) !== "test") { throw new Error("bad"); }; + /* c8 ignore stop */ + + if (form === "NFD") { + const check = String.fromCharCode(0xe9).normalize("NFD"); + const expected = String.fromCharCode(0x65, 0x0301) + /* c8 ignore start */ + if (check !== expected) { throw new Error("broken") } + /* c8 ignore stop */ + } + + accum.push(form); + } catch(error) { } + + return accum; +}, >[]); + +function defineReadOnly(object: T, name: P, value: T[P]): void { + Object.defineProperty(object, name, { + enumerable: true, writable: false, value, + }); +} + +// IEEE 754 support 53-bits of mantissa +const maxValue = 0x1fffffffffffff; + +// The type of error to use for various error codes +const ErrorConstructors: Record): Error }> = { }; +ErrorConstructors.INVALID_ARGUMENT = TypeError; +ErrorConstructors.NUMERIC_FAULT = RangeError; +ErrorConstructors.BUFFER_OVERRUN = RangeError; + +export type AssertFunc = () => (undefined | T); + +export class Logger { + readonly version!: string; + + #logLevel: number; + + constructor(version?: string) { + defineReadOnly(this, "version", version || "_"); + this.#logLevel = 1; + } + + get logLevel(): LogLevel { + return LogLevels[this.#logLevel]; + } + + set logLevel(value: LogLevel) { + const logLevel = LogLevels.indexOf(value); + if (logLevel == null) { + this.throwArgumentError("invalid logLevel", "logLevel", value); + } + this.#logLevel = logLevel; + } + + makeError>(message: string, code: K, info?: ErrorInfo): T { + { + const details: Array = []; + if (info) { + for (const key in info) { + const value = (info[>key]); + try { + details.push(key + "=" + JSON.stringify(value)); + } catch (error) { + details.push(key + "=[could not serialize object]"); + } + } + } + details.push(`code=${ code }`); + details.push(`version=${ this.version }`); + + if (details.length) { + message += " (" + details.join(", ") + ")"; + } + } + + const create = ErrorConstructors[code] || Error; + const error = (new create(message)); + defineReadOnly(error, "code", code); + if (info) { + for (const key in info) { + defineReadOnly(error, key, (info[>key])); + } + } + return error; + } + + throwError>(message: string, code: K, info?: ErrorInfo): never { + throw this.makeError(message, code, info); + } + + throwArgumentError(message: string, name: string, value: any): never { + return this.throwError(message, "INVALID_ARGUMENT", { + argument: name, + value: value + }); + } + + assertNormalize(form: string): void { + if (_normalizeForms.indexOf(form) === -1) { + this.throwError("platform missing String.prototype.normalize", "UNSUPPORTED_OPERATION", { + operation: "String.prototype.normalize", info: { form } + }); + } + } + + assertPrivate(givenGuard: any, guard: any, className = ""): void { + if (givenGuard !== guard) { + let method = className, operation = "new"; + if (className) { + method += "."; + operation += " " + className; + } + this.throwError(`private constructor; use ${ method }from* methods`, "UNSUPPORTED_OPERATION", { + operation + }); + } + } + + assertArgumentCount(count: number, expectedCount: number, message: string = ""): void { + if (message) { message = ": " + message; } + + if (count < expectedCount) { + this.throwError("missing arguemnt" + message, "MISSING_ARGUMENT", { + count: count, + expectedCount: expectedCount + }); + } + + if (count > expectedCount) { + this.throwError("too many arguemnts" + message, "UNEXPECTED_ARGUMENT", { + count: count, + expectedCount: expectedCount + }); + } + } + + #getBytes(value: BytesLike, name?: string, copy?: boolean): Uint8Array { + if (value instanceof Uint8Array) { + if (copy) { return new Uint8Array(value); } + return value; + } + + if (typeof(value) === "string" && value.match(/^0x([0-9a-f][0-9a-f])*$/i)) { + const result = new Uint8Array((value.length - 2) / 2); + let offset = 2; + for (let i = 0; i < result.length; i++) { + result[i] = parseInt(value.substring(offset, offset + 2), 16); + offset += 2; + } + return result; + } + + return this.throwArgumentError("invalid BytesLike value", name || "value", value); + } + + getBytes(value: BytesLike, name?: string): Uint8Array { + return this.#getBytes(value, name, false); + } + + getBytesCopy(value: BytesLike, name?: string): Uint8Array { + return this.#getBytes(value, name, true); + } + + getNumber(value: BigNumberish, name?: string): number { + switch (typeof(value)) { + case "bigint": + if (value < -maxValue || value > maxValue) { + this.throwArgumentError("overflow", name || "value", value); + } + return Number(value); + case "number": + if (!Number.isInteger(value)) { + this.throwArgumentError("underflow", name || "value", value); + } else if (value < -maxValue || value > maxValue) { + this.throwArgumentError("overflow", name || "value", value); + } + return value; + case "string": + try { + return this.getNumber(BigInt(value), name); + } catch(e: any) { + this.throwArgumentError(`invalid numeric string: ${ e.message }`, name || "value", value); + } + } + return this.throwArgumentError("invalid numeric value", name || "value", value); + } + + getBigInt(value: BigNumberish, name?: string): bigint { + switch (typeof(value)) { + case "bigint": return value; + case "number": + if (!Number.isInteger(value)) { + this.throwArgumentError("underflow", name || "value", value); + } else if (value < -maxValue || value > maxValue) { + this.throwArgumentError("overflow", name || "value", value); + } + return BigInt(value); + case "string": + try { + return BigInt(value); + } catch(e: any) { + this.throwArgumentError(`invalid BigNumberish string: ${ e.message }`, name || "value", value); + } + } + return this.throwArgumentError("invalid BigNumberish value", name || "value", value); + } + + #log(_logLevel: LogLevel, args: Array): void { + const logLevel = LogLevels.indexOf(_logLevel); + if (logLevel === -1) { + this.throwArgumentError("invalid log level name", "logLevel", _logLevel); + } + if (this.#logLevel > logLevel) { return; } + console.log.apply(console, args); + } + + debug(...args: Array): void { + this.#log("debug", args); + } + + info(...args: Array): void { + this.#log("info", args); + } + + warn(...args: Array): void { + this.#log("warning", args); + } +} + +export const logger = new Logger(version); + +export function assertArgument(check: unknown, message: string, name: string, value: unknown): asserts check { + if (!check) { logger.throwArgumentError(message, name, value); } +} + diff --git a/src.ts/utils/maths.ts b/src.ts/utils/maths.ts new file mode 100644 index 000000000..a50d52f01 --- /dev/null +++ b/src.ts/utils/maths.ts @@ -0,0 +1,134 @@ +import { hexlify, isBytesLike } from "./data.js"; +import { logger } from "./logger.js"; + +import type { BytesLike } from "./data.js"; + + +export type Numeric = number | bigint; +export type BigNumberish = string | Numeric; + + +const BN_0 = BigInt(0); +const BN_1 = BigInt(1); + +/** + * Convert %%value%% from a twos-compliment value of %%width%% bits. + */ +export function fromTwos(_value: BigNumberish, _width: Numeric): bigint { + const value = logger.getBigInt(_value, "value"); + const width = BigInt(logger.getNumber(_width, "width")); + + // Top bit set; treat as a negative value + if (value >> (width - BN_1)) { + const mask = (BN_1 << width) - BN_1; + return -(((~value) & mask) + BN_1); + } + + return value; +} + +/** + * Convert %%value%% to a twos-compliment value of %%width%% bits. + */ +export function toTwos(_value: BigNumberish, _width: Numeric): bigint { + const value = logger.getBigInt(_value, "value"); + const width = BigInt(logger.getNumber(_width, "width")); + + if (value < BN_0) { + const mask = (BN_1 << width) - BN_1; + return ((~(-value)) & mask) + BN_1; + } + + return value; +} + +/** + * Mask %%value%% with a bitmask of %%bits%% ones. + */ +export function mask(_value: BigNumberish, _bits: Numeric): bigint { + const value = logger.getBigInt(_value, "value"); + const bits = BigInt(logger.getNumber(_bits, "bits")); + return value & ((BN_1 << bits) - BN_1); +} + + + +/* + * Converts %%value%% to a BigInt. If %%value%% is a Uint8Array, it + * is treated as Big Endian data. + */ +const Nibbles = "0123456789abcdef"; +export function toBigInt(value: BigNumberish | Uint8Array): bigint { + if (value instanceof Uint8Array) { + let result = "0x0"; + for (const v of value) { + result += Nibbles[v >> 4]; + result += Nibbles[v & 0x0f]; + } + return BigInt(result); + } + + return logger.getBigInt(value); +} + +/* + * Converts %%value%% to a number. If %%value%% is a Uint8Array, it + * is treated as Big Endian data. Throws if the value is not safe. + */ +export function toNumber(value: BigNumberish | Uint8Array): number { + return logger.getNumber(toBigInt(value)); +} + +/** + * Converts %%value%% to a Big Endian hexstring, optionally padded to + * %%width%% bytes. + */ +// Converts value to hex, optionally padding on the left to width bytes +export function toHex(_value: BigNumberish, _width?: Numeric): string { + const value = logger.getBigInt(_value, "value"); + if (value < 0) { throw new Error("cannot convert negative value to hex"); } + + let result = value.toString(16); + + if (_width == null) { + // Ensure the value is of even length + if (result.length % 2) { result = "0" + result; } + } else { + const width = logger.getNumber(_width, "width"); + if (width * 2 < result.length) { throw new Error(`value ${ value } exceeds width ${ width }`); } + + // Pad the value to the required width + while (result.length < (width * 2)) { result = "0" + result; } + + } + + return "0x" + result; +} + +/** + * Converts %%value%% to a Big Endian Uint8Array. + */ +export function toArray(_value: BigNumberish): Uint8Array { + const value = logger.getBigInt(_value, "value"); + if (value < 0) { throw new Error("cannot convert negative value to hex"); } + + if (value === BN_0) { return new Uint8Array([ ]); } + + let hex = value.toString(16); + if (hex.length % 2) { hex = "0" + hex; } + + const result = new Uint8Array(hex.length / 2); + for (let i = 0; i < result.length; i++) { + const offset = i * 2; + result[i] = parseInt(hex.substring(offset, offset + 2), 16); + } + + return result; +} + +export function toQuantity(value: BytesLike | BigNumberish): string { + let result = hexlify(isBytesLike(value) ? value: toArray(value)).substring(2); + while (result.substring(0, 1) === "0") { result = result.substring(1); } + if (result === "") { result = "0"; } + return "0x" + result; +} diff --git a/src.ts/utils/properties.ts b/src.ts/utils/properties.ts new file mode 100644 index 000000000..bbaac7f71 --- /dev/null +++ b/src.ts/utils/properties.ts @@ -0,0 +1,110 @@ +export async function resolveProperties(value: { [ P in keyof T ]: T[P] | Promise}): Promise { + const keys = Object.keys(value); + const results = await Promise.all(keys.map((k) => Promise.resolve(value[k]))); + return results.reduce((accum: any, v, index) => { + accum[keys[index]] = v; + return accum; + }, <{ [ P in keyof T]: T[P] }>{ }); +} + +export function defineReadOnly(object: T, name: P, value: T[P]): void { + Object.defineProperty(object, name, { + enumerable: true, + value: value, + writable: false, + }); +} + +/* +export interface CancellablePromise extends Promise { + cancel(): Promise; +} +export type IsCancelled = () => Promise; + +export function createPromise(resolve: (isCancelled: IsCancelled, (result: T) => void) => void, reject: (error: Error) => void, isCancelled: IsCancelled): CancellablePromise { + let cancelled = false; + + const promise = new Promise((resolve, reject) => { + + }); + + (>promise).cancel = function() { + cancelled = true; + }; + + return (>promise); +} +*/ +/* +export class A implements Freezable { + foo: number; + constructor(foo: number) { + this.foo = foo; + } + freeze(): Frozen { + Object.freeze(this); + return this; + } + clone(): A { + return new A(this.foo); + } +} + +export class B implements Freezable { + a: A; + constructor(a: A) { + this.a = a; + } + freeze(): Frozen { + this.a.freeze(); + Object.freeze(this); + return this; + } + clone(): B { + return new B(this.a); + } +} + +export function test() { + const a = new A(123); + const b = new B(a); + b.a = new A(234); + const b2 = b.freeze(); + b2.a.foo = 123; // = a; +} +*/ + +function checkType(value: any, type: string): void { + const types = type.split("|").map(t => t.trim()); + for (let i = 0; i < types.length; i++) { + switch (type) { + case "any": + return; + case "boolean": + case "number": + case "string": + if (typeof(value) === type) { return; } + } + } + throw new Error("invalid value for type"); +} + +export function defineProperties( + target: T, + values: { [ K in keyof T ]?: undefined | T[K] }, + types?: { [ K in keyof T ]?: string }, + defaults?: { [ K in keyof T ]?: T[K] }): void { + + for (let key in values) { + let value = values[key]; + + const fallback = (defaults ? defaults[key]: undefined); + if (fallback !== undefined) { + value = fallback; + } else { + const type = (types ? types[key]: null); + if (type) { checkType(value, type); } + } + Object.defineProperty(target, key, { enumerable: true, value, writable: false }); + } +} diff --git a/src.ts/utils/rlp-decode.ts b/src.ts/utils/rlp-decode.ts new file mode 100644 index 000000000..cbc41ad42 --- /dev/null +++ b/src.ts/utils/rlp-decode.ts @@ -0,0 +1,108 @@ +//See: https://github.com/ethereum/wiki/wiki/RLP + +import { hexlify } from "./data.js"; +import { logger } from "./logger.js"; + +import type { BytesLike, RlpStructuredData } from "./index.js"; + + +function hexlifyByte(value: number): string { + let result = value.toString(16); + while (result.length < 2) { result = "0" + result; } + return "0x" + result; +} + +function unarrayifyInteger(data: Uint8Array, offset: number, length: number): number { + let result = 0; + for (let i = 0; i < length; i++) { + result = (result * 256) + data[offset + i]; + } + return result; +} + +type Decoded = { + result: any; + consumed: number; +}; + +function _decodeChildren(data: Uint8Array, offset: number, childOffset: number, length: number): Decoded { + const result = []; + + while (childOffset < offset + 1 + length) { + const decoded = _decode(data, childOffset); + + result.push(decoded.result); + + childOffset += decoded.consumed; + if (childOffset > offset + 1 + length) { + logger.throwError("child data too short", "BUFFER_OVERRUN", { + buffer: data, length, offset + }); + } + } + + return {consumed: (1 + length), result: result}; +} + +// returns { consumed: number, result: Object } +function _decode(data: Uint8Array, offset: number): { consumed: number, result: any } { + if (data.length === 0) { + logger.throwError("data too short", "BUFFER_OVERRUN", { + buffer: data, length: 0, offset: 1 + }); + } + + const checkOffset = (offset: number) => { + if (offset > data.length) { + logger.throwError("data short segment too short", "BUFFER_OVERRUN", { + buffer: data, length: data.length, offset + }); + } + }; + + // Array with extra length prefix + if (data[offset] >= 0xf8) { + const lengthLength = data[offset] - 0xf7; + checkOffset(offset + 1 + lengthLength); + + const length = unarrayifyInteger(data, offset + 1, lengthLength); + checkOffset(offset + 1 + lengthLength + length); + + return _decodeChildren(data, offset, offset + 1 + lengthLength, lengthLength + length); + + } else if (data[offset] >= 0xc0) { + const length = data[offset] - 0xc0; + checkOffset(offset + 1 + length); + + return _decodeChildren(data, offset, offset + 1, length); + + } else if (data[offset] >= 0xb8) { + const lengthLength = data[offset] - 0xb7; + checkOffset(offset + 1 + lengthLength); + + const length = unarrayifyInteger(data, offset + 1, lengthLength); + checkOffset(offset + 1 + lengthLength + length); + + const result = hexlify(data.slice(offset + 1 + lengthLength, offset + 1 + lengthLength + length)); + return { consumed: (1 + lengthLength + length), result: result } + + } else if (data[offset] >= 0x80) { + const length = data[offset] - 0x80; + checkOffset(offset + 1 + length); + + const result = hexlify(data.slice(offset + 1, offset + 1 + length)); + return { consumed: (1 + length), result: result } + } + + return { consumed: 1, result: hexlifyByte(data[offset]) }; +} + +export function decodeRlp(_data: BytesLike): RlpStructuredData { + const data = logger.getBytes(_data, "data"); + const decoded = _decode(data, 0); + if (decoded.consumed !== data.length) { + logger.throwArgumentError("unexpected junk after rlp payload", "data", _data); + } + return decoded.result; +} + diff --git a/src.ts/utils/rlp-encode.ts b/src.ts/utils/rlp-encode.ts new file mode 100644 index 000000000..37494d8e5 --- /dev/null +++ b/src.ts/utils/rlp-encode.ts @@ -0,0 +1,61 @@ +//See: https://github.com/ethereum/wiki/wiki/RLP + +import { logger } from "./logger.js"; + +import type { RlpStructuredData } from "./rlp.js"; + + +function arrayifyInteger(value: number): Array { + const result = []; + while (value) { + result.unshift(value & 0xff); + value >>= 8; + } + return result; +} + +function _encode(object: Array | string): Array { + if (Array.isArray(object)) { + let payload: Array = []; + object.forEach(function(child) { + payload = payload.concat(_encode(child)); + }); + + if (payload.length <= 55) { + payload.unshift(0xc0 + payload.length) + return payload; + } + + const length = arrayifyInteger(payload.length); + length.unshift(0xf7 + length.length); + + return length.concat(payload); + + } + + const data: Array = Array.prototype.slice.call(logger.getBytes(object, "object")); + + if (data.length === 1 && data[0] <= 0x7f) { + return data; + + } else if (data.length <= 55) { + data.unshift(0x80 + data.length); + return data; + } + + const length = arrayifyInteger(data.length); + length.unshift(0xb7 + length.length); + + return length.concat(data); +} + +const nibbles = "0123456789abcdef"; + +export function encodeRlp(object: RlpStructuredData): string { + let result = "0x"; + for (const v of _encode(object)) { + result += nibbles[v >> 4]; + result += nibbles[v & 0xf]; + } + return result; +} diff --git a/src.ts/utils/rlp.ts b/src.ts/utils/rlp.ts new file mode 100644 index 000000000..8f5c7209d --- /dev/null +++ b/src.ts/utils/rlp.ts @@ -0,0 +1,5 @@ + +export type RlpStructuredData = string | Array; + +export { decodeRlp } from "./rlp-decode.js"; +export { encodeRlp } from "./rlp-encode.js"; diff --git a/src.ts/utils/storage.ts b/src.ts/utils/storage.ts new file mode 100644 index 000000000..c3049a7e3 --- /dev/null +++ b/src.ts/utils/storage.ts @@ -0,0 +1,10 @@ +export function getStore(store: T, key: P): T[P] { + return store[key]; +} + +export function setStore(store: T, key: P, value: T[P]): void { + if (Object.isFrozen(store)) { + throw new Error(`frozen object is immuatable; cannot set ${ String(key) }`); + } + store[key] = value; +} diff --git a/src.ts/utils/units.ts b/src.ts/utils/units.ts new file mode 100644 index 000000000..b9556a582 --- /dev/null +++ b/src.ts/utils/units.ts @@ -0,0 +1,63 @@ +import { formatFixed, parseFixed } from "./fixednumber.js"; +import { logger } from "./logger.js"; + +import type { BigNumberish, Numeric } from "../utils/index.js"; + + +const names = [ + "wei", + "kwei", + "mwei", + "gwei", + "szabo", + "finney", + "ether", +]; + +/** + * Converts %%value%% into a //decimal string//, assuming %%unit%% decimal + * places. The %%unit%% may be the number of decimal places or the name of + * a unit (e.g. ``"gwei"`` for 9 decimal places). + * + */ +export function formatUnits(value: BigNumberish, unit?: string | Numeric): string { + if (typeof(unit) === "string") { + const index = names.indexOf(unit); + if (index === -1) { logger.throwArgumentError("invalid unit", "unit", unit); } + unit = 3 * index; + } + return formatFixed(value, (unit != null) ? unit: 18); +} + +/** + * Converts the //decimal string// %%value%% to a [[BigInt]], assuming + * %%unit%% decimal places. The %%unit%% may the number of decimal places + * or the name of a unit (e.g. ``"gwei"`` for 9 decimal places). + */ +export function parseUnits(value: string, unit?: string | Numeric): bigint { + if (typeof(value) !== "string") { + logger.throwArgumentError("value must be a string", "value", value); + } + + if (typeof(unit) === "string") { + const index = names.indexOf(unit); + if (index === -1) { logger.throwArgumentError("invalid unit", "unit", unit); } + unit = 3 * index; + } + return parseFixed(value, (unit != null) ? unit: 18); +} + +/** + * Converts %%value%% into a //decimal string// using 18 decimal places. + */ +export function formatEther(wei: BigNumberish): string { + return formatUnits(wei, 18); +} + +/** + * Converts the //decimal string// %%ether%% to a [[BigInt]], using 18 + * decimal places. + */ +export function parseEther(ether: string): bigint { + return parseUnits(ether, 18); +} diff --git a/src.ts/utils/utf8.ts b/src.ts/utils/utf8.ts new file mode 100644 index 000000000..362b598bc --- /dev/null +++ b/src.ts/utils/utf8.ts @@ -0,0 +1,285 @@ +import { logger } from "./logger.js"; + +import type { BytesLike } from "./index.js"; + + +/////////////////////////////// + +export type UnicodeNormalizationForm = "NFC" | "NFD" | "NFKC" | "NFKD"; + +export type Utf8ErrorReason = + // A continuation byte was present where there was nothing to continue + // - offset = the index the codepoint began in + "UNEXPECTED_CONTINUE" | + + // An invalid (non-continuation) byte to start a UTF-8 codepoint was found + // - offset = the index the codepoint began in + "BAD_PREFIX" | + + // The string is too short to process the expected codepoint + // - offset = the index the codepoint began in + "OVERRUN" | + + // A missing continuation byte was expected but not found + // - offset = the index the continuation byte was expected at + "MISSING_CONTINUE" | + + // The computed code point is outside the range for UTF-8 + // - offset = start of this codepoint + // - badCodepoint = the computed codepoint; outside the UTF-8 range + "OUT_OF_RANGE" | + + // UTF-8 strings may not contain UTF-16 surrogate pairs + // - offset = start of this codepoint + // - badCodepoint = the computed codepoint; inside the UTF-16 surrogate range + "UTF16_SURROGATE" | + + // The string is an overlong representation + // - offset = start of this codepoint + // - badCodepoint = the computed codepoint; already bounds checked + "OVERLONG"; + + +export type Utf8ErrorFunc = (reason: Utf8ErrorReason, offset: number, bytes: ArrayLike, output: Array, badCodepoint?: number) => number; + +function errorFunc(reason: Utf8ErrorReason, offset: number, bytes: ArrayLike, output: Array, badCodepoint?: number): number { + return logger.throwArgumentError(`invalid codepoint at offset ${ offset }; ${ reason }`, "bytes", bytes); +} + +function ignoreFunc(reason: Utf8ErrorReason, offset: number, bytes: ArrayLike, output: Array, badCodepoint?: number): number { + + // If there is an invalid prefix (including stray continuation), skip any additional continuation bytes + if (reason === "BAD_PREFIX" || reason === "UNEXPECTED_CONTINUE") { + let i = 0; + for (let o = offset + 1; o < bytes.length; o++) { + if (bytes[o] >> 6 !== 0x02) { break; } + i++; + } + return i; + } + + // This byte runs us past the end of the string, so just jump to the end + // (but the first byte was read already read and therefore skipped) + if (reason === "OVERRUN") { + return bytes.length - offset - 1; + } + + // Nothing to skip + return 0; +} + +function replaceFunc(reason: Utf8ErrorReason, offset: number, bytes: ArrayLike, output: Array, badCodepoint?: number): number { + + // Overlong representations are otherwise "valid" code points; just non-deistingtished + if (reason === "OVERLONG") { + output.push((badCodepoint != null) ? badCodepoint: -1); + return 0; + } + + // Put the replacement character into the output + output.push(0xfffd); + + // Otherwise, process as if ignoring errors + return ignoreFunc(reason, offset, bytes, output, badCodepoint); +} + +// Common error handing strategies +export const Utf8ErrorFuncs: Readonly> = Object.freeze({ + error: errorFunc, + ignore: ignoreFunc, + replace: replaceFunc +}); + +// http://stackoverflow.com/questions/13356493/decode-utf-8-with-javascript#13691499 +function getUtf8CodePoints(_bytes: BytesLike, onError?: Utf8ErrorFunc): Array { + if (onError == null) { onError = Utf8ErrorFuncs.error; } + + const bytes = logger.getBytes(_bytes, "bytes"); + + const result: Array = []; + let i = 0; + + // Invalid bytes are ignored + while(i < bytes.length) { + + const c = bytes[i++]; + + // 0xxx xxxx + if (c >> 7 === 0) { + result.push(c); + continue; + } + + // Multibyte; how many bytes left for this character? + let extraLength = null; + let overlongMask = null; + + // 110x xxxx 10xx xxxx + if ((c & 0xe0) === 0xc0) { + extraLength = 1; + overlongMask = 0x7f; + + // 1110 xxxx 10xx xxxx 10xx xxxx + } else if ((c & 0xf0) === 0xe0) { + extraLength = 2; + overlongMask = 0x7ff; + + // 1111 0xxx 10xx xxxx 10xx xxxx 10xx xxxx + } else if ((c & 0xf8) === 0xf0) { + extraLength = 3; + overlongMask = 0xffff; + + } else { + if ((c & 0xc0) === 0x80) { + i += onError("UNEXPECTED_CONTINUE", i - 1, bytes, result); + } else { + i += onError("BAD_PREFIX", i - 1, bytes, result); + } + continue; + } + + // Do we have enough bytes in our data? + if (i - 1 + extraLength >= bytes.length) { + i += onError("OVERRUN", i - 1, bytes, result); + continue; + } + + // Remove the length prefix from the char + let res: null | number = c & ((1 << (8 - extraLength - 1)) - 1); + + for (let j = 0; j < extraLength; j++) { + let nextChar = bytes[i]; + + // Invalid continuation byte + if ((nextChar & 0xc0) != 0x80) { + i += onError("MISSING_CONTINUE", i, bytes, result); + res = null; + break; + }; + + res = (res << 6) | (nextChar & 0x3f); + i++; + } + + // See above loop for invalid continuation byte + if (res === null) { continue; } + + // Maximum code point + if (res > 0x10ffff) { + i += onError("OUT_OF_RANGE", i - 1 - extraLength, bytes, result, res); + continue; + } + + // Reserved for UTF-16 surrogate halves + if (res >= 0xd800 && res <= 0xdfff) { + i += onError("UTF16_SURROGATE", i - 1 - extraLength, bytes, result, res); + continue; + } + + // Check for overlong sequences (more bytes than needed) + if (res <= overlongMask) { + i += onError("OVERLONG", i - 1 - extraLength, bytes, result, res); + continue; + } + + result.push(res); + } + + return result; +} + +// http://stackoverflow.com/questions/18729405/how-to-convert-utf8-string-to-byte-array +export function toUtf8Bytes(str: string, form?: UnicodeNormalizationForm): Uint8Array { + + if (form != null) { + logger.assertNormalize(form); + str = str.normalize(form); + } + + let result = []; + for (let i = 0; i < str.length; i++) { + const c = str.charCodeAt(i); + + if (c < 0x80) { + result.push(c); + + } else if (c < 0x800) { + result.push((c >> 6) | 0xc0); + result.push((c & 0x3f) | 0x80); + + } else if ((c & 0xfc00) == 0xd800) { + i++; + const c2 = str.charCodeAt(i); + + if (i >= str.length || (c2 & 0xfc00) !== 0xdc00) { + throw new Error("invalid utf-8 string"); + } + + // Surrogate Pair + const pair = 0x10000 + ((c & 0x03ff) << 10) + (c2 & 0x03ff); + result.push((pair >> 18) | 0xf0); + result.push(((pair >> 12) & 0x3f) | 0x80); + result.push(((pair >> 6) & 0x3f) | 0x80); + result.push((pair & 0x3f) | 0x80); + + } else { + result.push((c >> 12) | 0xe0); + result.push(((c >> 6) & 0x3f) | 0x80); + result.push((c & 0x3f) | 0x80); + } + } + + return new Uint8Array(result); +}; + +function escapeChar(value: number) { + const hex = ("0000" + value.toString(16)); + return "\\u" + hex.substring(hex.length - 4); +} + +export function _toEscapedUtf8String(bytes: BytesLike, onError?: Utf8ErrorFunc): string { + return '"' + getUtf8CodePoints(bytes, onError).map((codePoint) => { + if (codePoint < 256) { + switch (codePoint) { + case 8: return "\\b"; + case 9: return "\\t"; + case 10: return "\\n" + case 13: return "\\r"; + case 34: return "\\\""; + case 92: return "\\\\"; + } + + if (codePoint >= 32 && codePoint < 127) { + return String.fromCharCode(codePoint); + } + } + + if (codePoint <= 0xffff) { + return escapeChar(codePoint); + } + + codePoint -= 0x10000; + return escapeChar(((codePoint >> 10) & 0x3ff) + 0xd800) + escapeChar((codePoint & 0x3ff) + 0xdc00); + }).join("") + '"'; +} + +export function _toUtf8String(codePoints: Array): string { + return codePoints.map((codePoint) => { + if (codePoint <= 0xffff) { + return String.fromCharCode(codePoint); + } + codePoint -= 0x10000; + return String.fromCharCode( + (((codePoint >> 10) & 0x3ff) + 0xd800), + ((codePoint & 0x3ff) + 0xdc00) + ); + }).join(""); +} + +export function toUtf8String(bytes: BytesLike, onError?: Utf8ErrorFunc): string { + return _toUtf8String(getUtf8CodePoints(bytes, onError)); +} + +export function toUtf8CodePoints(str: string, form?: UnicodeNormalizationForm): Array { + return getUtf8CodePoints(toUtf8Bytes(str, form)); +} diff --git a/src.ts/wallet/base-wallet.ts b/src.ts/wallet/base-wallet.ts new file mode 100644 index 000000000..3bbe2b629 --- /dev/null +++ b/src.ts/wallet/base-wallet.ts @@ -0,0 +1,84 @@ +import { getAddress, resolveAddress } from "../address/index.js"; +import { hashMessage, TypedDataEncoder } from "../hash/index.js"; +import { AbstractSigner } from "../providers/index.js"; +import { computeAddress, Transaction } from "../transaction/index.js"; +import { defineProperties, logger, resolveProperties } from "../utils/index.js"; + +import type { SigningKey } from "../crypto/index.js"; +import type { TypedDataDomain, TypedDataField } from "../hash/index.js"; +import type { Provider, TransactionRequest } from "../providers/index.js"; +import type { TransactionLike } from "../transaction/index.js"; + + +export class BaseWallet extends AbstractSigner { + readonly address!: string; + + readonly #signingKey: SigningKey; + + constructor(privateKey: SigningKey, provider?: null | Provider) { + super(provider); + this.#signingKey = privateKey; + + const address = computeAddress(this.signingKey.publicKey); + defineProperties(this, { address }); + } + + // Store these in getters to reduce visibility in console.log + get signingKey(): SigningKey { return this.#signingKey; } + get privateKey(): string { return this.signingKey.privateKey; } + + async getAddress(): Promise { return this.address; } + + connect(provider: null | Provider): BaseWallet { + return new BaseWallet(this.#signingKey, provider); + } + + async signTransaction(_tx: TransactionRequest): Promise { + // Replace any Addressable or ENS name with an address + const tx = >Object.assign({ }, _tx, await resolveProperties({ + to: (_tx.to ? resolveAddress(_tx.to, this.provider): undefined), + from: (_tx.from ? resolveAddress(_tx.from, this.provider): undefined) + })); + + if (tx.from != null) { + if (getAddress(tx.from) !== this.address) { + logger.throwArgumentError("transaction from address mismatch", "tx.from", _tx.from); + } + delete tx.from; + } + + // Build the transaction + const btx = Transaction.from(tx); + btx.signature = this.signingKey.sign(btx.unsignedHash); + + return btx.serialized; + } + + async signMessage(message: string | Uint8Array): Promise { + return this.signingKey.sign(hashMessage(message)).serialized; + } + + async signTypedData(domain: TypedDataDomain, types: Record>, value: Record): Promise { + + // Populate any ENS names + const populated = await TypedDataEncoder.resolveNames(domain, types, value, async (name: string) => { + if (this.provider == null) { + return logger.throwError("cannot resolve ENS names without a provider", "UNSUPPORTED_OPERATION", { + operation: "resolveName", + info: { name } + }); + } + + const address = await this.provider.resolveName(name); + if (address == null) { + return logger.throwError("unconfigured ENS name", "UNCONFIGURED_NAME", { + value: name + }); + } + + return address; + }); + + return this.signingKey.sign(TypedDataEncoder.hash(populated.domain, types, populated.value)).serialized; + } +} diff --git a/src.ts/wallet/hdwallet.ts b/src.ts/wallet/hdwallet.ts new file mode 100644 index 000000000..a7077a88c --- /dev/null +++ b/src.ts/wallet/hdwallet.ts @@ -0,0 +1,352 @@ +import { computeHmac, randomBytes, ripemd160, SigningKey, sha256 } from "../crypto/index.js"; +import { VoidSigner } from "../providers/index.js"; +import { computeAddress } from "../transaction/index.js"; +import { + concat, dataSlice, decodeBase58, defineProperties, encodeBase58, hexlify, logger, toBigInt, toHex +} from "../utils/index.js"; +import { langEn } from "../wordlists/lang-en.js"; + +import { Mnemonic } from "./mnemonic.js"; +import { BaseWallet } from "./base-wallet.js"; + +import type { BytesLike, Numeric } from "../utils/index.js"; +import type { Provider } from "../providers/index.js"; +import type { Wordlist } from "../wordlists/index.js"; + + +export const defaultPath = "m/44'/60'/0'/0/0"; + + +// "Bitcoin seed" +const MasterSecret = new Uint8Array([ 66, 105, 116, 99, 111, 105, 110, 32, 115, 101, 101, 100 ]); + +const HardenedBit = 0x80000000; + +const N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"); + +const Nibbles = "0123456789abcdef"; +function zpad(value: number, length: number): string { + let result = ""; + while (value) { + result = Nibbles[value % 16] + result; + value = Math.trunc(value / 16); + } + while (result.length < length * 2) { result = "0" + result; } + return "0x" + result; +} + +function encodeBase58Check(_value: BytesLike): string { + const value = logger.getBytes(_value); + const check = dataSlice(sha256(sha256(value)), 0, 4); + const bytes = concat([ value, check ]); + return encodeBase58(bytes); +} + +const _guard = { }; + +function ser_I(index: number, chainCode: string, publicKey: string, privateKey: null | string): { IL: Uint8Array, IR: Uint8Array } { + const data = new Uint8Array(37); + + if (index & HardenedBit) { + if (privateKey == null) { + return logger.throwError("cannot derive child of neutered node", "UNSUPPORTED_OPERATION", { + operation: "deriveChild" + }); + } + + // Data = 0x00 || ser_256(k_par) + data.set(logger.getBytes(privateKey), 1); + + } else { + // Data = ser_p(point(k_par)) + data.set(logger.getBytes(publicKey)); + } + + // Data += ser_32(i) + for (let i = 24; i >= 0; i -= 8) { data[33 + (i >> 3)] = ((index >> (24 - i)) & 0xff); } + const I = logger.getBytes(computeHmac("sha512", chainCode, data)); + + return { IL: I.slice(0, 32), IR: I.slice(32) }; +} + +type HDNodeLike = { depth: number, deriveChild: (i: number) => T }; +function derivePath>(node: T, path: string): T { + const components = path.split("/"); + + if (components.length === 0 || (components[0] === "m" && node.depth !== 0)) { + throw new Error("invalid path - " + path); + } + + if (components[0] === "m") { components.shift(); } + + let result: T = node; + for (let i = 0; i < components.length; i++) { + const component = components[i]; + + if (component.match(/^[0-9]+'$/)) { + const index = parseInt(component.substring(0, component.length - 1)); + if (index >= HardenedBit) { throw new Error("invalid path index - " + component); } + result = result.deriveChild(HardenedBit + index); + + } else if (component.match(/^[0-9]+$/)) { + const index = parseInt(component); + if (index >= HardenedBit) { throw new Error("invalid path index - " + component); } + result = result.deriveChild(index); + + } else { + throw new Error("invalid path component - " + component); + } + } + + return result; +} + + +export interface HDNodeWithPath { + path: string; +} + +export class HDNodeWallet extends BaseWallet { + readonly publicKey!: string; + + readonly fingerprint!: string; + readonly parentFingerprint!: string; + + readonly mnemonic!: null | Mnemonic; + + readonly chainCode!: string; + + readonly path!: null | string; + readonly index!: number; + readonly depth!: number; + + constructor(guard: any, signingKey: SigningKey, parentFingerprint: string, chainCode: string, path: null | string, index: number, depth: number, mnemonic: null | Mnemonic, provider: null | Provider) { + super(signingKey, provider); + logger.assertPrivate(guard, _guard, "HDNodeWallet"); + + defineProperties(this, { publicKey: signingKey.compressedPublicKey }); + + const fingerprint = dataSlice(ripemd160(sha256(this.publicKey)), 0, 4); + defineProperties(this, { + parentFingerprint, fingerprint, + chainCode, path, index, depth + }); + + defineProperties(this, { mnemonic }); + } + + connect(provider: null | Provider): HDNodeWallet { + return new HDNodeWallet(_guard, this.signingKey, this.parentFingerprint, + this.chainCode, this.path, this.index, this.depth, this.mnemonic, provider); + } + + get extendedKey(): string { + // We only support the mainnet values for now, but if anyone needs + // testnet values, let me know. I believe current sentiment is that + // we should always use mainnet, and use BIP-44 to derive the network + // - Mainnet: public=0x0488B21E, private=0x0488ADE4 + // - Testnet: public=0x043587CF, private=0x04358394 + + if (this.depth >= 256) { throw new Error("Depth too large!"); } + + return encodeBase58Check(concat([ + "0x0488ADE4", zpad(this.depth, 1), this.parentFingerprint, + zpad(this.index, 4), this.chainCode, + concat([ "0x00", this.privateKey ]) + ])); + } + + hasPath(): this is { path: string } { return (this.path != null); } + + neuter(): HDNodeVoidWallet { + return new HDNodeVoidWallet(_guard, this.address, this.publicKey, + this.parentFingerprint, this.chainCode, this.path, this.index, + this.depth, this.provider); + } + + deriveChild(_index: Numeric): HDNodeWallet { + const index = logger.getNumber(_index, "index"); + if (index > 0xffffffff) { throw new Error("invalid index - " + String(index)); } + + // Base path + let path = this.path; + if (path) { + path += "/" + (index & ~HardenedBit); + if (index & HardenedBit) { path += "'"; } + } + + const { IR, IL } = ser_I(index, this.chainCode, this.publicKey, this.privateKey); + const ki = new SigningKey(toHex((toBigInt(IL) + BigInt(this.privateKey)) % N, 32)); + + return new HDNodeWallet(_guard, ki, this.fingerprint, hexlify(IR), + path, index, this.depth + 1, this.mnemonic, this.provider); + + } + + derivePath(path: string): HDNodeWallet { + return derivePath(this, path); + } + + static #fromSeed(_seed: BytesLike, mnemonic: null | Mnemonic): HDNodeWallet { + const seed = logger.getBytes(_seed, "seed"); + if (seed.length < 16 || seed.length > 64) { + throw new Error("invalid seed"); + } + + const I = logger.getBytes(computeHmac("sha512", MasterSecret, seed)); + const signingKey = new SigningKey(hexlify(I.slice(0, 32))); + + return new HDNodeWallet(_guard, signingKey, "0x00000000", hexlify(I.slice(32)), + "m", 0, 0, mnemonic, null); + } + + static fromSeed(seed: BytesLike): HDNodeWallet { + return HDNodeWallet.#fromSeed(seed, null); + } + + static fromPhrase(phrase: string, password = "", path: null | string = defaultPath, wordlist: Wordlist = langEn): HDNodeWallet { + if (!path) { path = defaultPath; } + const mnemonic = Mnemonic.fromPhrase(phrase, password, wordlist) + return HDNodeWallet.#fromSeed(mnemonic.computeSeed(), mnemonic).derivePath(path); + } + + static fromMnemonic(mnemonic: Mnemonic, path: null | string = defaultPath): HDNodeWallet { + if (!path) { path = defaultPath; } + return HDNodeWallet.#fromSeed(mnemonic.computeSeed(), mnemonic).derivePath(path); + } + + static fromExtendedKey(extendedKey: string): HDNodeWallet | HDNodeVoidWallet { + const bytes = logger.getBytes(decodeBase58(extendedKey)); // @TODO: redact + + if (bytes.length !== 82 || encodeBase58Check(bytes.slice(0, 78)) !== extendedKey) { + logger.throwArgumentError("invalid extended key", "extendedKey", "[ REDACTED ]"); + } + + const depth = bytes[4]; + const parentFingerprint = hexlify(bytes.slice(5, 9)); + const index = parseInt(hexlify(bytes.slice(9, 13)).substring(2), 16); + const chainCode = hexlify(bytes.slice(13, 45)); + const key = bytes.slice(45, 78); + + switch (hexlify(bytes.slice(0, 4))) { + // Public Key + case "0x0488b21e": case "0x043587cf": { + const publicKey = hexlify(key); + return new HDNodeVoidWallet(_guard, computeAddress(publicKey), publicKey, + parentFingerprint, chainCode, null, index, depth, null); + } + + // Private Key + case "0x0488ade4": case "0x04358394 ": + if (key[0] !== 0) { break; } + return new HDNodeWallet(_guard, new SigningKey(key.slice(1)), + parentFingerprint, chainCode, null, index, depth, null, null); + } + + + return logger.throwArgumentError("invalid extended key prefix", "extendedKey", "[ REDACTED ]"); + } + + static createRandom(password = "", path: null | string = defaultPath, wordlist: Wordlist = langEn): HDNodeWallet { + if (!path) { path = defaultPath; } + const mnemonic = Mnemonic.fromEntropy(randomBytes(16), password, wordlist) + return HDNodeWallet.#fromSeed(mnemonic.computeSeed(), mnemonic).derivePath(path); + } +} + +export class HDNodeVoidWallet extends VoidSigner { + readonly publicKey!: string; + + readonly fingerprint!: string; + readonly parentFingerprint!: string; + + readonly chainCode!: string; + + readonly path!: null | string; + readonly index!: number; + readonly depth!: number; + + constructor(guard: any, address: string, publicKey: string, parentFingerprint: string, chainCode: string, path: null | string, index: number, depth: number, provider: null | Provider) { + super(address, provider); + logger.assertPrivate(guard, _guard, "HDNodeVoidWallet"); + + defineProperties(this, { publicKey }); + + const fingerprint = dataSlice(ripemd160(sha256(publicKey)), 0, 4); + defineProperties(this, { + publicKey, fingerprint, parentFingerprint, chainCode, path, index, depth + }); + } + + connect(provider: null | Provider): HDNodeVoidWallet { + return new HDNodeVoidWallet(_guard, this.address, this.publicKey, + this.parentFingerprint, this.chainCode, this.path, this.index, this.depth, provider); + } + + get extendedKey(): string { + // We only support the mainnet values for now, but if anyone needs + // testnet values, let me know. I believe current sentiment is that + // we should always use mainnet, and use BIP-44 to derive the network + // - Mainnet: public=0x0488B21E, private=0x0488ADE4 + // - Testnet: public=0x043587CF, private=0x04358394 + + if (this.depth >= 256) { throw new Error("Depth too large!"); } + + return encodeBase58Check(concat([ + "0x0488B21E", + zpad(this.depth, 1), + this.parentFingerprint, + zpad(this.index, 4), + this.chainCode, + this.publicKey, + ])); + } + + hasPath(): this is { path: string } { return (this.path != null); } + + deriveChild(_index: Numeric): HDNodeVoidWallet { + const index = logger.getNumber(_index, "index"); + if (index > 0xffffffff) { throw new Error("invalid index - " + String(index)); } + + // Base path + let path = this.path; + if (path) { + path += "/" + (index & ~HardenedBit); + if (index & HardenedBit) { path += "'"; } + } + + const { IR, IL } = ser_I(index, this.chainCode, this.publicKey, null); + const Ki = SigningKey._addPoints(IL, this.publicKey, true); + + const address = computeAddress(Ki); + + return new HDNodeVoidWallet(_guard, address, Ki, this.fingerprint, hexlify(IR), + path, index, this.depth + 1, this.provider); + + } + + derivePath(path: string): HDNodeVoidWallet { + return derivePath(this, path); + } +} + +export class HDNodeWalletManager { + #root: HDNodeWallet; + + constructor(phrase: string, password = "", path = "m/44'/60'/0'/0", locale: Wordlist = langEn) { + this.#root = HDNodeWallet.fromPhrase(phrase, password, path, locale); + } + + getSigner(index = 0): HDNodeWallet { + return this.#root.deriveChild(index); + } +} + +export function getAccountPath(_index: Numeric): string { + const index = logger.getNumber(_index, "index"); + if (index < 0 || index >= HardenedBit) { + logger.throwArgumentError("invalid account index", "index", index); + } + return `m/44'/60'/${ index }'/0/0`; +} + diff --git a/src.ts/wallet/index.ts b/src.ts/wallet/index.ts new file mode 100644 index 000000000..842a5e6db --- /dev/null +++ b/src.ts/wallet/index.ts @@ -0,0 +1,22 @@ +export { + defaultPath, + + getAccountPath, + + HDNodeWallet, + HDNodeVoidWallet, + HDNodeWalletManager, +} from "./hdwallet.js"; +export { isCrowdsaleJson, decryptCrowdsaleJson } from "./json-crowdsale.js"; +export { + isKeystoreJson, + decryptKeystoreJsonSync, decryptKeystoreJson, + encryptKeystoreJson +} from "./json-keystore.js"; +export { Mnemonic } from "./mnemonic.js"; +export { Wallet } from "./wallet.js"; + +export type { + KeystoreAccountParams, KeystoreAccount, + EncryptOptions +} from "./json-keystore.js" diff --git a/src.ts/wallet/json-crowdsale.ts b/src.ts/wallet/json-crowdsale.ts new file mode 100644 index 000000000..23c3c7376 --- /dev/null +++ b/src.ts/wallet/json-crowdsale.ts @@ -0,0 +1,54 @@ +import { CBC, pkcs7Strip } from "aes-js"; + +import { getAddress } from "../address/index.js"; +import { pbkdf2 } from "../crypto/index.js"; +import { id } from "../hash/id.js"; +import { logger } from "../utils/index.js"; + +import { getPassword, looseArrayify, spelunk } from "./utils.js"; + + +export interface CrowdsaleAccount { + privateKey: string; + address: string; +} + +export function isCrowdsaleJson(json: string): boolean { + try { + const data = JSON.parse(json); + if (data.encseed) { return true; } + } catch (error) { } + return false; +} + +// See: https://github.com/ethereum/pyethsaletool +export function decryptCrowdsaleJson(json: string, _password: string | Uint8Array): CrowdsaleAccount { + const data = JSON.parse(json); + const password = getPassword(_password); + + // Ethereum Address + const address = getAddress(spelunk(data, "ethaddr:string!")); + + // Encrypted Seed + const encseed = looseArrayify(spelunk(data, "encseed:string!")); + if (!encseed || (encseed.length % 16) !== 0) { + logger.throwArgumentError("invalid encseed", "json", json); + } + + const key = logger.getBytes(pbkdf2(password, password, 2000, 32, "sha256")).slice(0, 16); + + const iv = encseed.slice(0, 16); + const encryptedSeed = encseed.slice(16); + + // Decrypt the seed + const aesCbc = new CBC(key, iv); + const seed = pkcs7Strip(logger.getBytes(aesCbc.decrypt(encryptedSeed))); + + // This wallet format is weird... Convert the binary encoded hex to a string. + let seedHex = ""; + for (let i = 0; i < seed.length; i++) { + seedHex += String.fromCharCode(seed[i]); + } + + return { address, privateKey: id(seedHex) }; +} diff --git a/src.ts/wallet/json-keystore.ts b/src.ts/wallet/json-keystore.ts new file mode 100644 index 000000000..1f9f19775 --- /dev/null +++ b/src.ts/wallet/json-keystore.ts @@ -0,0 +1,367 @@ +import { CTR } from "aes-js"; + +import { getAddress } from "../address/index.js"; +import { keccak256, pbkdf2, randomBytes, scrypt, scryptSync } from "../crypto/index.js"; +import { computeAddress } from "../transaction/index.js"; +import { concat, hexlify, logger } from "../utils/index.js"; + +import { getPassword, spelunk, uuidV4, zpad } from "./utils.js"; + +import type { ProgressCallback } from "../crypto/index.js"; +import type { BytesLike } from "../utils/index.js"; + +import { version } from "../_version.js"; + +const defaultPath = "m/44'/60'/0'/0/0"; + + +export type KeystoreAccountParams = { + privateKey: string; + address?: string; + mnemonic?: { + entropy: string; + path: string; + locale: string; + }; +}; + +export type KeystoreAccount = { + address: string; + privateKey: string; + mnemonic?: { + entropy: string; + path: string; + locale: string; + }; +}; + +export type EncryptOptions = { + iv?: BytesLike; + entropy?: BytesLike; + client?: string; + salt?: BytesLike; + uuid?: string; + scrypt?: { + N?: number; + r?: number; + p?: number; + } +} + +export function isKeystoreJson(json: string): boolean { + try { + const data = JSON.parse(json); + const version = ((data.version != null) ? parseInt(data.version): 0); + if (version === 3) { return true; } + } catch (error) { } + return false; +} + +function decrypt(data: any, key: Uint8Array, ciphertext: Uint8Array): string { + const cipher = spelunk(data, "crypto.cipher:string"); + if (cipher === "aes-128-ctr") { + const iv = spelunk(data, "crypto.cipherparams.iv:data!") + const aesCtr = new CTR(key, iv); + return hexlify(aesCtr.decrypt(ciphertext)); + } + + return logger.throwError("unsupported cipher", "UNSUPPORTED_OPERATION", { + operation: "decrypt" + }); +} + +function getAccount(data: any, _key: string): KeystoreAccount { + const key = logger.getBytes(_key); + const ciphertext = spelunk(data, "crypto.ciphertext:data!"); + + const computedMAC = hexlify(keccak256(concat([ key.slice(16, 32), ciphertext ]))).substring(2); + if (computedMAC !== spelunk(data, "crypto.mac:string!").toLowerCase()) { + return logger.throwArgumentError("incorrect password", "password", "[ REDACTED ]"); + } + + const privateKey = decrypt(data, key.slice(0, 16), ciphertext); + + const address = computeAddress(privateKey); + if (data.address) { + let check = data.address.toLowerCase(); + if (check.substring(0, 2) !== "0x") { check = "0x" + check; } + + if (getAddress(check) !== address) { + logger.throwArgumentError("keystore address/privateKey mismatch", "address", data.address); + } + } + + const account: KeystoreAccount = { address, privateKey }; + + // Version 0.1 x-ethers metadata must contain an encrypted mnemonic phrase + const version = spelunk(data, "x-ethers.version:string"); + if (version === "0.1") { + const mnemonicKey = key.slice(32, 64); + + const mnemonicCiphertext = spelunk(data, "x-ethers.mnemonicCiphertext:data!"); + const mnemonicIv = spelunk(data, "x-ethers.mnemonicCounter:data!"); + + const mnemonicAesCtr = new CTR(mnemonicKey, mnemonicIv); + + account.mnemonic = { + path: (spelunk(data, "x-ethers.path:string") || defaultPath), + locale: (spelunk(data, "x-ethers.locale:string") || "en"), + entropy: hexlify(logger.getBytes(mnemonicAesCtr.decrypt(mnemonicCiphertext))) + }; + } + + return account; +} + +type KdfParams = { + name: "scrypt"; + salt: Uint8Array; + N: number; + r: number; + p: number; + dkLen: number; +} | { + name: "pbkdf2"; + salt: Uint8Array; + count: number; + dkLen: number; + algorithm: "sha256" | "sha512"; +}; + +function getKdfParams(data: any): KdfParams { + const kdf = spelunk(data, "crypto.kdf:string"); + if (kdf && typeof(kdf) === "string") { + const throwError = function(name: string, value: any): never { + return logger.throwArgumentError("invalid key-derivation function parameters", name, value); + } + + if (kdf.toLowerCase() === "scrypt") { + const salt = spelunk(data, "crypto.kdfparams.salt:data!"); + const N = spelunk(data, "crypto.kdfparams.n:int!"); + const r = spelunk(data, "crypto.kdfparams.r:int!"); + const p = spelunk(data, "crypto.kdfparams.p:int!"); + + // Check for all required parameters + if (!N || !r || !p) { return throwError("kdf", kdf); } + + // Make sure N is a power of 2 + if ((N & (N - 1)) !== 0) { return throwError("N", N); } + + const dkLen = spelunk(data, "crypto.kdfparams.dklen:int!"); + if (dkLen !== 32) { return throwError("dklen", dkLen); } + + return { name: "scrypt", salt, N, r, p, dkLen: 64 }; + + } else if (kdf.toLowerCase() === "pbkdf2") { + + const salt = spelunk(data, "crypto.kdfparams.salt:data!"); + + const prf = spelunk(data, "crypto.kdfparams.prf:string!"); + const algorithm = prf.split("-").pop(); + if (algorithm !== "sha256" && algorithm !== "sha512") { + return throwError("prf", prf); + } + + const count = spelunk(data, "crypto.kdfparams.c:int!"); + + const dkLen = spelunk(data, "crypto.kdfparams.dklen:int!"); + if (dkLen !== 32) { throwError("dklen", dkLen); } + + return { name: "pbkdf2", salt, count, dkLen, algorithm }; + } + } + + return logger.throwArgumentError("unsupported key-derivation function", "kdf", kdf); +} + + +export function decryptKeystoreJsonSync(json: string, _password: string | Uint8Array): KeystoreAccount { + const data = JSON.parse(json); + + const password = getPassword(_password); + + const params = getKdfParams(data); + if (params.name === "pbkdf2") { + const { salt, count, dkLen, algorithm } = params; + const key = pbkdf2(password, salt, count, dkLen, algorithm); + return getAccount(data, key); + } else if (params.name === "scrypt") { + const { salt, N, r, p, dkLen } = params; + const key = scryptSync(password, salt, N, r, p, dkLen); + return getAccount(data, key); + } + + throw new Error("unreachable"); +} + +function stall(duration: number): Promise { + return new Promise((resolve) => { setTimeout(() => { resolve(); }, duration); }); +} + +export async function decryptKeystoreJson(json: string, _password: string | Uint8Array, progress?: ProgressCallback): Promise { + const data = JSON.parse(json); + + const password = getPassword(_password); + + const params = getKdfParams(data); + if (params.name === "pbkdf2") { + if (progress) { + progress(0); + await stall(0); + } + const { salt, count, dkLen, algorithm } = params; + const key = pbkdf2(password, salt, count, dkLen, algorithm); + if (progress) { + progress(1); + await stall(0); + } + return getAccount(data, key); + } else if (params.name === "scrypt") { + const { salt, N, r, p, dkLen } = params; + const key = await scrypt(password, salt, N, r, p, dkLen, progress); + return getAccount(data, key); + } + + throw new Error("unreachable"); +} + + +export async function encryptKeystoreJson(account: KeystoreAccount, password: string | Uint8Array, options?: EncryptOptions, progressCallback?: ProgressCallback): Promise { + + // Check the address matches the private key + //if (getAddress(account.address) !== computeAddress(account.privateKey)) { + // throw new Error("address/privateKey mismatch"); + //} + + // Check the mnemonic (if any) matches the private key + /* + if (hasMnemonic(account)) { + const mnemonic = account.mnemonic; + const node = HDNode.fromMnemonic(mnemonic.phrase, null, mnemonic.locale).derivePath(mnemonic.path || defaultPath); + + if (node.privateKey != account.privateKey) { + throw new Error("mnemonic mismatch"); + } + } + */ + + // The options are optional, so adjust the call as needed + if (typeof(options) === "function" && !progressCallback) { + progressCallback = options; + options = {}; + } + if (!options) { options = {}; } + + const privateKey = logger.getBytes(account.privateKey, "privateKey"); + const passwordBytes = getPassword(password); + +/* + let mnemonic: null | Mnemonic = null; + let entropy: Uint8Array = null + let path: string = null; + let locale: string = null; + if (hasMnemonic(account)) { + const srcMnemonic = account.mnemonic; + entropy = arrayify(mnemonicToEntropy(srcMnemonic.phrase, srcMnemonic.locale || "en")); + path = srcMnemonic.path || defaultPath; + locale = srcMnemonic.locale || "en"; + mnemonic = Mnemonic.from( + } +*/ + // Check/generate the salt + const salt = (options.salt != null) ? logger.getBytes(options.salt, "options.slat"): randomBytes(32); + + // Override initialization vector + const iv = (options.iv != null) ? logger.getBytes(options.iv, "options.iv"): randomBytes(16); + if (iv.length !== 16) { + logger.throwArgumentError("invalid options.iv", "options.iv", options.iv); + } + + // Override the uuid + const uuidRandom = (options.uuid != null) ? logger.getBytes(options.uuid, "options.uuid"): randomBytes(16); + if (uuidRandom.length !== 16) { + logger.throwArgumentError("invalid options.uuid", "options.uuid", options.iv); + } + if (uuidRandom.length !== 16) { throw new Error("invalid uuid"); } + + // Override the scrypt password-based key derivation function parameters + let N = (1 << 17), r = 8, p = 1; + if (options.scrypt) { + if (options.scrypt.N) { N = options.scrypt.N; } + if (options.scrypt.r) { r = options.scrypt.r; } + if (options.scrypt.p) { p = options.scrypt.p; } + } + + // We take 64 bytes: + // - 32 bytes As normal for the Web3 secret storage (derivedKey, macPrefix) + // - 32 bytes AES key to encrypt mnemonic with (required here to be Ethers Wallet) + const _key = await scrypt(passwordBytes, salt, N, r, p, 64, progressCallback); + const key = logger.getBytes(_key); + + // This will be used to encrypt the wallet (as per Web3 secret storage) + const derivedKey = key.slice(0, 16); + const macPrefix = key.slice(16, 32); + + // Encrypt the private key + const aesCtr = new CTR(derivedKey, iv); + const ciphertext = logger.getBytes(aesCtr.encrypt(privateKey)); + + // Compute the message authentication code, used to check the password + const mac = keccak256(concat([ macPrefix, ciphertext ])) + + // See: https://github.com/ethereum/wiki/wiki/Web3-Secret-Storage-Definition + const data: { [key: string]: any } = { + address: account.address.substring(2).toLowerCase(), + id: uuidV4(uuidRandom), + version: 3, + Crypto: { + cipher: "aes-128-ctr", + cipherparams: { + iv: hexlify(iv).substring(2), + }, + ciphertext: hexlify(ciphertext).substring(2), + kdf: "scrypt", + kdfparams: { + salt: hexlify(salt).substring(2), + n: N, + dklen: 32, + p: p, + r: r + }, + mac: mac.substring(2) + } + }; + + // If we have a mnemonic, encrypt it into the JSON wallet + if (account.mnemonic) { + const client = (options.client != null) ? options.client: `ethers/${ version }`; + + const path = account.mnemonic.path || defaultPath; + const locale = account.mnemonic.locale || "en"; + + const mnemonicKey = key.slice(32, 64); + + const entropy = logger.getBytes(account.mnemonic.entropy, "account.mnemonic.entropy"); + const mnemonicIv = randomBytes(16); + const mnemonicAesCtr = new CTR(mnemonicKey, mnemonicIv); + const mnemonicCiphertext = logger.getBytes(mnemonicAesCtr.encrypt(entropy)); + + const now = new Date(); + const timestamp = (now.getUTCFullYear() + "-" + + zpad(now.getUTCMonth() + 1, 2) + "-" + + zpad(now.getUTCDate(), 2) + "T" + + zpad(now.getUTCHours(), 2) + "-" + + zpad(now.getUTCMinutes(), 2) + "-" + + zpad(now.getUTCSeconds(), 2) + ".0Z"); + const gethFilename = ("UTC--" + timestamp + "--" + data.address); + + data["x-ethers"] = { + client, gethFilename, path, locale, + mnemonicCounter: hexlify(mnemonicIv).substring(2), + mnemonicCiphertext: hexlify(mnemonicCiphertext).substring(2), + version: "0.1" + }; + } + + return JSON.stringify(data); +} diff --git a/src.ts/wallet/mnemonic.ts b/src.ts/wallet/mnemonic.ts new file mode 100644 index 000000000..9a502da27 --- /dev/null +++ b/src.ts/wallet/mnemonic.ts @@ -0,0 +1,154 @@ +import { pbkdf2, sha256 } from "../crypto/index.js"; +import { defineProperties, hexlify, logger, toUtf8Bytes } from "../utils/index.js"; +import { langEn } from "../wordlists/lang-en.js"; + +import type { BytesLike } from "../utils/index.js"; +import type { Wordlist } from "../wordlists/index.js"; + + +// Returns a byte with the MSB bits set +function getUpperMask(bits: number): number { + return ((1 << bits) - 1) << (8 - bits) & 0xff; +} + +// Returns a byte with the LSB bits set +function getLowerMask(bits: number): number { + return ((1 << bits) - 1) & 0xff; +} + + +function mnemonicToEntropy(mnemonic: string, wordlist: null | Wordlist = langEn): string { + logger.assertNormalize("NFKD"); + + if (wordlist == null) { wordlist = langEn; } + + const words = wordlist.split(mnemonic); + if ((words.length % 3) !== 0 || words.length < 12 || words.length > 24) { + logger.throwArgumentError("invalid mnemonic length", "mnemonic", "[ REDACTED ]"); + } + + const entropy = new Uint8Array(Math.ceil(11 * words.length / 8)); + + let offset = 0; + for (let i = 0; i < words.length; i++) { + let index = wordlist.getWordIndex(words[i].normalize("NFKD")); + if (index === -1) { + logger.throwArgumentError(`invalid mnemonic word at index ${ i }`, "mnemonic", "[ REDACTED ]"); + } + + for (let bit = 0; bit < 11; bit++) { + if (index & (1 << (10 - bit))) { + entropy[offset >> 3] |= (1 << (7 - (offset % 8))); + } + offset++; + } + } + + const entropyBits = 32 * words.length / 3; + + + const checksumBits = words.length / 3; + const checksumMask = getUpperMask(checksumBits); + + const checksum = logger.getBytes(sha256(entropy.slice(0, entropyBits / 8)))[0] & checksumMask; + + if (checksum !== (entropy[entropy.length - 1] & checksumMask)) { + logger.throwArgumentError("invalid mnemonic checksum", "mnemonic", "[ REDACTED ]"); + } + + return hexlify(entropy.slice(0, entropyBits / 8)); +} + +function entropyToMnemonic(entropy: Uint8Array, wordlist: null | Wordlist = langEn): string { + if ((entropy.length % 4) || entropy.length < 16 || entropy.length > 32) { + logger.throwArgumentError("invalid entropy size", "entropy", "[ REDACTED ]"); + } + + if (wordlist == null) { wordlist = langEn; } + + const indices: Array = [ 0 ]; + + let remainingBits = 11; + for (let i = 0; i < entropy.length; i++) { + + // Consume the whole byte (with still more to go) + if (remainingBits > 8) { + indices[indices.length - 1] <<= 8; + indices[indices.length - 1] |= entropy[i]; + + remainingBits -= 8; + + // This byte will complete an 11-bit index + } else { + indices[indices.length - 1] <<= remainingBits; + indices[indices.length - 1] |= entropy[i] >> (8 - remainingBits); + + // Start the next word + indices.push(entropy[i] & getLowerMask(8 - remainingBits)); + + remainingBits += 3; + } + } + + // Compute the checksum bits + const checksumBits = entropy.length / 4; + const checksum = parseInt(sha256(entropy).substring(2, 4), 16) & getUpperMask(checksumBits); + + // Shift the checksum into the word indices + indices[indices.length - 1] <<= checksumBits; + indices[indices.length - 1] |= (checksum >> (8 - checksumBits)); + + return wordlist.join(indices.map((index) => (wordlist).getWord(index))); +} + +const _guard = { }; + +export class Mnemonic { + readonly phrase!: string; + readonly password!: string; + readonly wordlist!: Wordlist; + + readonly entropy!: string; + + constructor(guard: any, entropy: string, phrase: string, password?: null | string, wordlist?: null | Wordlist) { + if (password == null) { password = ""; } + if (wordlist == null) { wordlist = langEn; } + logger.assertPrivate(guard, _guard, "Mnemonic"); + defineProperties(this, { phrase, password, wordlist, entropy }); + } + + computeSeed(): string { + const salt = toUtf8Bytes("mnemonic" + this.password, "NFKD"); + return pbkdf2(toUtf8Bytes(this.phrase, "NFKD"), salt, 2048, 64, "sha512"); + } + + static fromPhrase(phrase: string, password?: null | string, wordlist?: null | Wordlist) { + // Normalize the case and space; throws if invalid + const entropy = mnemonicToEntropy(phrase, wordlist); + phrase = entropyToMnemonic(logger.getBytes(entropy), wordlist); + return new Mnemonic(_guard, entropy, phrase, password, wordlist); + } + + static fromEntropy(_entropy: BytesLike, password?: null | string, wordlist?: null | Wordlist): Mnemonic { + const entropy = logger.getBytes(_entropy, "entropy"); + const phrase = entropyToMnemonic(entropy, wordlist); + return new Mnemonic(_guard, hexlify(entropy), phrase, password, wordlist); + } + + static entropyToPhrase(_entropy: BytesLike, wordlist?: null | Wordlist): string { + const entropy = logger.getBytes(_entropy, "entropy"); + return entropyToMnemonic(entropy, wordlist); + } + + static phraseToEntropy(phrase: string, wordlist?: null | Wordlist): string { + return mnemonicToEntropy(phrase, wordlist); + } + + static isValidMnemonic(phrase: string, wordlist?: null | Wordlist): boolean { + try { + mnemonicToEntropy(phrase, wordlist); + return true; + } catch (error) { } + return false; + } +} diff --git a/src.ts/wallet/utils.ts b/src.ts/wallet/utils.ts new file mode 100644 index 000000000..e2258dfea --- /dev/null +++ b/src.ts/wallet/utils.ts @@ -0,0 +1,146 @@ +import { hexlify, logger, toUtf8Bytes } from "../utils/index.js"; + +import type { BytesLike } from "../utils/index.js"; + + +export function looseArrayify(hexString: string): Uint8Array { + if (typeof(hexString) === 'string' && hexString.substring(0, 2) !== '0x') { + hexString = '0x' + hexString; + } + return logger.getBytesCopy(hexString); +} + +export function zpad(value: String | number, length: number): String { + value = String(value); + while (value.length < length) { value = '0' + value; } + return value; +} + +export function getPassword(password: string | Uint8Array): Uint8Array { + if (typeof(password) === 'string') { + return toUtf8Bytes(password, "NFKC"); + } + return logger.getBytesCopy(password); +} + +export function spelunk(object: any, _path: string): T { + + const match = _path.match(/^([a-z0-9$_.-]*)(:([a-z]+))?(!)?$/i); + if (match == null) { + return logger.throwArgumentError("invalid path", "path", _path); + } + const path = match[1]; + const type = match[3]; + const reqd = (match[4] === "!"); + + let cur = object; + for (const comp of path.toLowerCase().split('.')) { + + // Search for a child object with a case-insensitive matching key + if (Array.isArray(cur)) { + if (!comp.match(/^[0-9]+$/)) { break; } + cur = cur[parseInt(comp)]; + + } else if (typeof(cur) === "object") { + let found: any = null; + for (const key in cur) { + if (key.toLowerCase() === comp) { + found = cur[key]; + break; + } + } + cur = found; + + } else { + cur = null; + } + + if (cur == null) { break; } + } + + if (reqd && cur == null) { + logger.throwArgumentError("missing required value", "path", path); + } + + if (type && cur != null) { + if (type === "int") { + if (typeof(cur) === "string" && cur.match(/^-?[0-9]+$/)) { + return parseInt(cur); + } else if (Number.isSafeInteger(cur)) { + return cur; + } + } + + if (type === "number") { + if (typeof(cur) === "string" && cur.match(/^-?[0-9.]*$/)) { + return parseFloat(cur); + } + } + + if (type === "data") { + if (typeof(cur) === "string") { return looseArrayify(cur); } + } + + if (type === "array" && Array.isArray(cur)) { return cur; } + if (type === typeof(cur)) { return cur; } + + logger.throwArgumentError(`wrong type found for ${ type } `, "path", path); + } + + return cur; +} +/* +export function follow(object: any, path: string): null | string { + let currentChild = object; + + for (const comp of path.toLowerCase().split('/')) { + + // Search for a child object with a case-insensitive matching key + let matchingChild = null; + for (const key in currentChild) { + if (key.toLowerCase() === comp) { + matchingChild = currentChild[key]; + break; + } + } + + if (matchingChild === null) { return null; } + + currentChild = matchingChild; + } + + return currentChild; +} + +// "path/to/something:type!" +export function followRequired(data: any, path: string): string { + const value = follow(data, path); + if (value != null) { return value; } + return logger.throwArgumentError("invalid value", `data:${ path }`, + JSON.stringify(data)); +} +*/ +// See: https://www.ietf.org/rfc/rfc4122.txt (Section 4.4) +export function uuidV4(randomBytes: BytesLike): string { + const bytes = logger.getBytes(randomBytes, "randomBytes"); + + // Section: 4.1.3: + // - time_hi_and_version[12:16] = 0b0100 + bytes[6] = (bytes[6] & 0x0f) | 0x40; + + // Section 4.4 + // - clock_seq_hi_and_reserved[6] = 0b0 + // - clock_seq_hi_and_reserved[7] = 0b1 + bytes[8] = (bytes[8] & 0x3f) | 0x80; + + const value = hexlify(bytes); + + return [ + value.substring(2, 10), + value.substring(10, 14), + value.substring(14, 18), + value.substring(18, 22), + value.substring(22, 34), + ].join("-"); +} + diff --git a/src.ts/wallet/wallet.ts b/src.ts/wallet/wallet.ts new file mode 100644 index 000000000..c9466460d --- /dev/null +++ b/src.ts/wallet/wallet.ts @@ -0,0 +1,166 @@ +import { randomBytes, SigningKey } from "../crypto/index.js"; +import { computeAddress } from "../transaction/index.js"; +import { isHexString, logger } from "../utils/index.js"; + +import { BaseWallet } from "./base-wallet.js"; +import { HDNodeWallet } from "./hdwallet.js"; +import { decryptCrowdsaleJson, isCrowdsaleJson } from "./json-crowdsale.js"; +import { + decryptKeystoreJson, decryptKeystoreJsonSync, isKeystoreJson +} from "./json-keystore.js"; +import { Mnemonic } from "./mnemonic.js"; + +import type { ProgressCallback } from "../crypto/index.js"; +import type { Provider } from "../providers/index.js"; +import type { Wordlist } from "../wordlists/index.js"; + +import type { CrowdsaleAccount } from "./json-crowdsale.js"; +import type { KeystoreAccount } from "./json-keystore.js"; + + +function tryWallet(value: any): null | Wallet { + try { + if (!value || !value.signingKey) { return null; } + const key = trySigningKey(value.signingKey); + if (key == null || computeAddress(key.publicKey) !== value.address) { return null; } + if (value.mnemonic) { + const wallet = HDNodeWallet.fromMnemonic(value.mnemonic); + if (wallet.privateKey !== key.privateKey) { return null; } + } + return value; + } catch (e) { console.log(e); } + return null; +} + +// Try using value as mnemonic to derive the defaultPath HDodeWallet +function tryMnemonic(value: any): null | HDNodeWallet { + try { + if (value == null || typeof(value.phrase) !== "string" || + typeof(value.password) !== "string" || + value.wordlist == null) { return null; } + return HDNodeWallet.fromPhrase(value.phrase, value.password, null, value.wordlist); + } catch (error) { console.log(error); } + return null; +} + +function trySigningKey(value: any): null | SigningKey { + try { + if (!value || !isHexString(value.privateKey, 32)) { return null; } + + const key = value.privateKey; + if (SigningKey.computePublicKey(key) !== value.publicKey) { return null; } + return new SigningKey(key); + } catch (e) { console.log(e); } + return null; +} + +function stall(duration: number): Promise { + return new Promise((resolve) => { setTimeout(() => { resolve(); }, duration); }); +} + +export class Wallet extends BaseWallet { + readonly #mnemonic: null | Mnemonic; + + constructor(key: string | Mnemonic | SigningKey | BaseWallet, provider?: null | Provider) { + let signingKey: null | SigningKey = null; + let mnemonic: null | Mnemonic = null; + + // A normal private key + if (typeof(key) === "string") { signingKey = new SigningKey(key); } + + // Try Wallet + if (signingKey == null) { + const wallet = tryWallet(key); + if (wallet) { + signingKey = wallet.signingKey; + mnemonic = wallet.mnemonic || null; + } + } + + // Try Mnemonic, with the defaultPath wallet + if (signingKey == null) { + const wallet = tryMnemonic(key); + if (wallet) { + signingKey = wallet.signingKey; + mnemonic = wallet.mnemonic || null; + } + } + + // A signing key + if (signingKey == null) { signingKey = trySigningKey(key); } + + if (signingKey == null) { + logger.throwArgumentError("invalid key", "key", "[ REDACTED ]"); + } + + super(signingKey as SigningKey, provider); + this.#mnemonic = mnemonic; + } + + // Store this in a getter to reduce visibility in console.log + get mnemonic(): null | Mnemonic { return this.#mnemonic; } + + connect(provider: null | Provider): Wallet { + return new Wallet(this, provider); + } + + async encrypt(password: Uint8Array | string, options?: any, progressCallback?: ProgressCallback): Promise { + throw new Error("TODO"); + } + + encryptSync(password: Uint8Array | string, options?: any): Promise { + throw new Error("TODO"); + } + + static async fromEncryptedJson(json: string, password: Uint8Array | string, progress?: ProgressCallback): Promise { + let account: null | CrowdsaleAccount | KeystoreAccount = null; + if (isKeystoreJson(json)) { + account = await decryptKeystoreJson(json, password, progress); + + } else if (isCrowdsaleJson(json)) { + if (progress) { progress(0); await stall(0); } + account = decryptCrowdsaleJson(json, password); + if (progress) { progress(1); await stall(0); } + + } else { + return logger.throwArgumentError("invalid JSON wallet", "json", "[ REDACTED ]"); + } + + const wallet = new Wallet(account.privateKey); + if (wallet.address !== account.address) { + logger.throwArgumentError("address/privateKey mismatch", "json", "[ REDACTED ]"); + } + // @TODO: mnemonic + return wallet; + } + + static fromEncryptedJsonSync(json: string, password: Uint8Array | string): Wallet { + let account: null | CrowdsaleAccount | KeystoreAccount = null; + if (isKeystoreJson(json)) { + account = decryptKeystoreJsonSync(json, password); + } else if (isCrowdsaleJson(json)) { + account = decryptCrowdsaleJson(json, password); + } else { + return logger.throwArgumentError("invalid JSON wallet", "json", "[ REDACTED ]"); + } + + const wallet = new Wallet(account.privateKey); + if (wallet.address !== account.address) { + logger.throwArgumentError("address/privateKey mismatch", "json", "[ REDACTED ]"); + } + // @TODO: mnemonic + return wallet; + } + + static createRandom(provider?: null | Provider, password?: null | string, wordlist?: null | Wordlist): Wallet { + return new Wallet(Mnemonic.fromEntropy(randomBytes(16), password, wordlist), provider); + } + + static fromMnemonic(mnemonic: Mnemonic, provider?: null | Provider): Wallet { + return new Wallet(mnemonic, provider); + } + + static fromPhrase(phrase: string, provider?: null | Provider, password = "", wordlist?: Wordlist): Wallet { + return new Wallet(Mnemonic.fromPhrase(phrase, password, wordlist), provider); + } +} diff --git a/src.ts/wordlists/bit-reader.ts b/src.ts/wordlists/bit-reader.ts new file mode 100644 index 000000000..cc316adca --- /dev/null +++ b/src.ts/wordlists/bit-reader.ts @@ -0,0 +1,32 @@ +const Base64 = ")!@#$%^&*(ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_"; + +export function decodeBits(width: number, data: string): Array { + const maxValue = (1 << width) - 1; + const result: Array = [ ]; + let accum = 0, bits = 0, flood = 0; + for (let i = 0; i < data.length; i++) { + + // Accumulate 6 bits of data + accum = ((accum << 6) | Base64.indexOf(data[i])); + bits += 6; + + // While we have enough for a word... + while (bits >= width) { + // ...read the word + const value = (accum >> (bits - width)); + accum &= (1 << (bits - width)) - 1; + bits -= width; + + // A value of 0 indicates we exceeded maxValue, it + // floods over into the next value + if (value === 0) { + flood += maxValue; + } else { + result.push(value + flood); + flood = 0; + } + } + } + + return result; +} diff --git a/src.ts/wordlists/decode-owl.ts b/src.ts/wordlists/decode-owl.ts new file mode 100644 index 000000000..cfdc9a284 --- /dev/null +++ b/src.ts/wordlists/decode-owl.ts @@ -0,0 +1,52 @@ +import { assertArgument } from "../utils/logger.js"; + + +const subsChrs = " !#$%&'()*+,-./<=>?@[]^_`{|}~"; +const Word = /^[a-z]*$/i; + +function unfold(words: Array, sep: string): Array { + let initial = 97; + return words.reduce((accum, word) => { + if (word === sep) { + initial++; + } else if (word.match(Word)) { + accum.push(String.fromCharCode(initial) + word); + } else { + initial = 97; + accum.push(word); + } + return accum; + }, >[]); +} + +export function decode(data: string, subs: string): Array { + + // Replace all the substitutions with their expanded form + for (let i = subsChrs.length - 1; i >= 0; i--) { + data = data.split(subsChrs[i]).join(subs.substring(2 * i, 2 * i + 2)); + } + + // Get all tle clumps; each suffix, first-increment and second-increment + const clumps: Array = [ ]; + const leftover = data.replace(/(:|([0-9])|([A-Z][a-z]*))/g, (all, item, semi, word) => { + if (semi) { + for (let i = parseInt(semi); i >= 0; i--) { clumps.push(";"); } + } else { + clumps.push(item.toLowerCase()); + } + return ""; + }); + /* c8 ignore start */ + if (leftover) { throw new Error(`leftovers: ${ JSON.stringify(leftover) }`); } + /* c8 ignore stop */ + + return unfold(unfold(clumps, ";"), ":"); +} + +export function decodeOwl(data: string): Array { + assertArgument(data[0] === "0", "unsupported auwl data", "data", data); + + return decode( + data.substring(1 + 2 * subsChrs.length), + data.substring(1, 1 + 2 * subsChrs.length)); +} diff --git a/src.ts/wordlists/decode-owla.ts b/src.ts/wordlists/decode-owla.ts new file mode 100644 index 000000000..cb6424fde --- /dev/null +++ b/src.ts/wordlists/decode-owla.ts @@ -0,0 +1,30 @@ +import { assertArgument } from "../utils/logger.js"; + +import { decodeBits } from "./bit-reader.js"; +import { decodeOwl } from "./decode-owl.js"; + +export function decodeOwlA(data: string, accents: string): Array { + let words = decodeOwl(data).join(","); + + // Inject the accents + accents.split(/,/g).forEach((accent) => { + + const match = accent.match(/^([a-z]*)([0-9]+)([0-9])(.*)$/); + assertArgument(match !== null, "internal error parsing accents", "accents", accents); + + let posOffset = 0; + const positions = decodeBits(parseInt(match[3]), match[4]); + const charCode = parseInt(match[2]); + const regex = new RegExp(`([${ match[1] }])`, "g"); + words = words.replace(regex, (all, letter) => { + const rem = --positions[posOffset]; + if (rem === 0) { + letter = String.fromCharCode(letter.charCodeAt(0), charCode); + posOffset++; + } + return letter; + }); + }); + + return words.split(","); +} diff --git a/src.ts/wordlists/generation/encode-latin.ts b/src.ts/wordlists/generation/encode-latin.ts new file mode 100644 index 000000000..6777042f4 --- /dev/null +++ b/src.ts/wordlists/generation/encode-latin.ts @@ -0,0 +1,370 @@ + +// OWL Data Format +// +// The Official WordList data format exported by this encoder +// encodes sorted latin-1 words (letters only) based on the +// fact that sorted words have prefixes with substantial +// overlap. +// +// For example, the words: +// [ Another, Apple, Apricot, Bread ] +// could be folded once with a single special character, such +// as ":" to yield: +// [ nother, pple, pricot, :, read ]. +// The First letter has been removed, but can be inferred by +// starting at A and incrementing to the next letter when ":" +// is encountered. +// +// The fold operation can be repeated for large sets as even within +// each folded set, there is substatial overlap in prefix. With the +// second special symbol ";", we get: +// [ ; x 13, other, :, ple, ricot, :, ; x 18, ead ] +// which can be further compressed by using numbers instead of the +// special character: +// [ 13, other, :, ple, ricot, :, 18, ead ] +// and to keep all values within a single byte, we only allow a +// maximum value of 10 (using 0 through 9 to represent 1 through 10), +// we get: +// [ 9, 2, other, :, ple, ricot, :, 9, 7, ead ] +// and we use camel-case to imply the bounrary, giving the final string: +// "92Other:PleRicot:97Ead" +// +// Once the entire latin-1 set has been collapsed, we use the remaining +// printable characters (except " and \, which require 2 bytes to represent +// in string) to substiture for the most common 2-letter pairs of letters +// in the string. +// +// OWLA Accent Format +// +// OWLA first removes all accents, and encodes that data using the OWL +// data format and encodes the accents as a base-64 series of 6-bit +// packed bits representing the distance from one followed letter to the +// next. +// +// For example, the acute accent in a given language may follow either +// a or e, in which case the follow-set is "ae". Each letter in the entire +// set is indexed, so the set of words with the accents: +// "thisA/ppleDoe/sNotMa/tterToMe/" +// " 1^ 2^ 3^ 4^ 5^ 6^ " <-- follow-set members, ALL a's and e's +// which gives the positions: +// [ 0, 2, 3, 4, 6 ] +// which then reduce to the distances +// [ 0, 2, 1, 1, 2 ] +// each of which fit into a 2-bit value, so this can be encoded as the +// base-64 encoded string: +// 00 10 01 01 10 = 001001 1010xx +// +// The base-64 set used has all number replaced with their +// shifted-counterparts to prevent comflicting with the numbers used in +// the fold operation to indicate the number of ";". + +import fs from "fs"; + +import { id } from "../../hash/id.js"; + +import { decodeOwl } from "../decode-owl.js"; +import { decodeOwlA } from "../decode-owla.js"; + +const subsChrs = " !#$%&'()*+,-./<=>?@[]^_`{|}~"; + +const Word = /^[a-z'`]*$/i; + +function fold(words: Array, sep: string): Array { + const output: Array = [ ]; + + let initial = 97; + for (const word of words) { + if (word.match(Word)) { + while (initial < word.charCodeAt(0)) { + initial++; + output.push(sep); + } + output.push(word.substring(1)); + } else { + initial = 97; + output.push(word); + } + } + + return output; +} + +function camelcase(words: Array): string { + return words.map((word) => { + if (word.match(Word)) { + return word[0].toUpperCase() + word.substring(1); + } else { + return word; + } + }).join(""); +} + +//let cc = 0, ce = 0; +/* +function getChar(c: string): string { + //if (c === "e") { ce++; } + if (c >= 'a' && c <= 'z') { return c; } + if (c.charCodeAt(1)) { + throw new Error(`bad char: "${ c }"`); + } + //cc++; + return ""; + if (c.charCodeAt(0) === 768) { return "`"; } + if (c.charCodeAt(0) === 769) { return "'"; } + if (c.charCodeAt(0) === 771) { return "~"; } + throw new Error(`Unsupported character: ${ c } (${ c.charCodeAt(0) }, ${ c.charCodeAt(1) })`); +} +function mangle(text: string): { word: string, special: string } { + const result: Array = [ ]; + for (let i = 0; i < text.length; i++) { + const c = getChar(text[i]); + result.push(c); + } + + const word = result.join(""); + if (word[1] >= 'a' && word[1] <= 'z') { return { word, special: " " }; } + return { word: word[0] + word.substring(2), special: word[1] }; +} +*/ +/* + Store: [ accent ][ targets ][ rle data; base64-tail ] + ` ae 3, 100 = (63, 37), 15 + ~ n 63, 64 = (63, 1), 27 +*/ + +const Base64 = ")!@#$%^&*(ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz-_"; +export class BitWriter { + readonly width: number; + readonly #data: Array; + + #bitLength: number; + + constructor(width: number) { + this.width = width; + this.#data = [ ]; + this.#bitLength = 0; + } + + write(value: number): void { + const maxValue = ((1 << this.width) - 1); + while (value > maxValue) { + this.#data.push(0); + this.#bitLength += this.width; + value -= maxValue; + } + this.#data.push(value); + this.#bitLength += this.width; + } + + get length(): number { + return 1 + Math.trunc((this.#bitLength + 5) / 6); + } + + get data(): string { + let result = String(this.width); + let bits = 0; + let accum = 0; + + const data = this.#data.slice(); + let bitMod = this.#bitLength % 6; + while (bitMod !== 0 && bitMod < 6) { + data.push(0); + bitMod += this.width; + } + + for (const value of data) { + accum <<= this.width; + accum |= value; + bits += this.width; + + if (bits < 6) { continue; } + + result += Base64[accum >> (bits - 6)]; + bits -= 6; + accum &= ((1 << bits) - 1); + } + + if (result.length !== this.length) { + throw new Error(`Hmm: ${ this.length } ${ result.length } ${ result }`); + } + return result; + } +} + +export interface AccentSet { + accent: number; + follows: string; + positions: Array; + positionsLength: number; + positionData: string; + positionDataLength: number; +}; + +function sorted(text: string): string { + const letters = text.split(""); + letters.sort(); + return letters.join(""); +} + +// if (c.charCodeAt(0) === 768) { return "`"; } +// if (c.charCodeAt(0) === 769) { return "'"; } +// if (c.charCodeAt(0) === 771) { return "~"; } +export function extractAccents(words: Array): { accents: Array, words: Array } { + + // Build a list that maps accents to the letters it can follow + const followsMap: Map = new Map(); + for (const word of words) { + for (let i = 0; i < word.length; i++) { + const c = word[i]; + if (c >= 'a' && c <= 'z') { continue; } + + // Make sure this positions and codepoint make sense + if (c.charCodeAt(1)) { throw new Error(`unsupported codepoint: "${ c }"`); } + if (i === 0) { throw new Error(`unmatched accent: ${ c }`); } + + const ac = c.charCodeAt(0), lastLetter = word[i - 1];; + const follows = (followsMap.get(ac) || ""); + if (follows.indexOf(lastLetter) === -1) { + followsMap.set(ac, sorted(follows + lastLetter)); + } + } + } + + // Build the positions of each follow-set for those accents + const positionsMap: Map> = new Map(); + for (const [ accent, follows ] of followsMap) { + let count = 0; + for (const word of words) { + for (let i = 0; i < word.length; i++) { + const c = word[i], ac = c.charCodeAt(0); + if (follows.indexOf(c) >= 0) { count++; } + if (ac === accent) { + const pos = positionsMap.get(ac) || [ ]; + pos.push(count); + positionsMap.set(ac, pos); + } + } + } + } + + const accents: Array = [ ]; + for (const [ accent, follows ] of followsMap) { + let last = -1; + const positions = (positionsMap.get(accent) || [ ]).map((value, index) => { + const delta = value - last; + last = value; + if (index === 0) { return value; } + return delta; + }); + + // Find the best encoding of the position data + let positionData = ""; + for (let i = 2; i < 7; i++) { + const bitWriter = new BitWriter(i); + for (const p of positions) { bitWriter.write(p); } + if (positionData === "" || bitWriter.length < positionData.length) { + positionData = bitWriter.data; + } + } + const positionsLength = positions.length; + const positionDataLength = positionData.length; + + accents.push({ accent, follows, positions, positionsLength, positionData, positionDataLength }); + } + + words = words.map((word) => { + let result = ""; + for (let i = 0; i < word.length; i++) { + const c = word[i]; + if (c >= 'a' && c <= 'z') { result += c } + } + return result; + }); + + return { accents, words }; +} + +// Encode Official WordList +export function encodeOwl(words: Array): { subs: string, data: string } { + + // Fold the sorted words by indicating delta for the first 2 letters + let data = camelcase(fold(fold(words, ":"), ";")); + + // Replace semicolons with counts (e.g. ";;;" with "3") + data = data.replace(/(;+)/g, (all, semis) => { + let result = ""; + while (semis.length) { + let count = semis.length; + if (count > 10) { count = 10; } + result += String(count - 1); + semis = semis.substring(count); + } + return result; + }); + + // Finds the best option for a shortcut replacement using the + // unused ascii7 characters + function findBest(): string { + const tally: Record = { }; + const l = 2; + for (let i = l; i < data.length; i++) { + const key = data.substring(i - l, i); + tally[key] = (tally[key] || 0) + 1; + } + + const sorted: Array<{ text: string, count: number, save: number }> = Object.keys(tally).map((text) => { + return { text, count: tally[text], save: (tally[text] * (text.length - 1)) } + }); + sorted.sort((a, b) => (b.save - a.save)); + + return sorted[0].text; + } + + // Make substitutions + let subs = ""; + for (let i = 0; i < subsChrs.length; i++) { + const n = subsChrs[i], o = findBest(); + subs += o; + data = data.split(o).join(n); + } + + return { data, subs }; +} + +// Returns either: +// - OWL data for accent-free latin-1: { data, accentds: "" } +// - OWLA data for accented latin-1: { data, accents } +function encodeWords(_words: Array): { data: string, accents: string } { + const { accents, words } = extractAccents(_words); + const { data, subs } = encodeOwl(words); + const accentData = accents.map(({ accent, follows, positionData }) => { + return `${ follows }${ accent }${ positionData }`; + }).join(","); + + return { + data: `0${ subs }${data}`, + accents: accentData + }; +} + +// CLI +const content = fs.readFileSync(process.argv[2]).toString(); +const words = content.split("\n").filter(Boolean); +const { data, accents } = encodeWords(words); + +if (accents) { + const rec = decodeOwlA(data, accents); + console.log("DATA: ", JSON.stringify(data)); + console.log("ACCENTS: ", JSON.stringify(accents)); + console.log("LENGTH: ", data.length); + console.log("CHECKSUM: ", id(content)); + console.log("RATIO: ", Math.trunc(100 * data.length / content.length) + "%"); + if (rec.join("\n") !== words.join("\n")) { throw new Error("no match!"); } +} else { + const rec = decodeOwl(data); + console.log("DATA: ", JSON.stringify(data)); + console.log("LENGTH: ", data.length); + console.log("CHECKSUM: ", id(content)); + console.log("RATIO: ", Math.trunc(100 * data.length / content.length) + "%"); + if (rec.join("\n") !== words.join("\n")) { throw new Error("no match!"); } +} diff --git a/src.ts/wordlists/index.ts b/src.ts/wordlists/index.ts new file mode 100644 index 000000000..776e4f86e --- /dev/null +++ b/src.ts/wordlists/index.ts @@ -0,0 +1,7 @@ + +export { Wordlist } from "./wordlist.js"; +export { langEn, LangEn } from "./lang-en.js"; +export { wordlists } from "./wordlists.js"; + +export { WordlistOwl } from "./wordlist-owl.js"; +export { WordlistOwlA } from "./wordlist-owla.js"; diff --git a/src.ts/wordlists/lang-cz.ts b/src.ts/wordlists/lang-cz.ts new file mode 100644 index 000000000..debf6fedc --- /dev/null +++ b/src.ts/wordlists/lang-cz.ts @@ -0,0 +1,10 @@ +import { WordlistOwl } from "./wordlist-owl.js"; + +const words = "0itatkastcenaovo$taouleraeki&chor*teci%enbalodaeladet'!Chn=0Di#%E%^1Resa2Rese3CeT'#0EjKohol0Pu)%0A&sDul#Ekdo)Ke)Ti#Ul|3}aOgan%0FaltI$@tPi,%TmaTronom0LasL{i#Ol0Tobus4Yl:B#}R'?TaUb_U/!U^U+Ur!Xer2A^v#Ambo,An#AtrEp)Ike)KoLohOnzOskevUn{#Usin#Z^Zy2Bl.Bn|})D _D#D'aF{Jar(Kv?LdokLvaN^NkrRzaTikVolZola3D+tL.T'#0Ukot:PartRev&3DrDu+J/JnLaLerLkemLn?N.Nn(N'#NtrumNzZ(2O&2KolivUv!4It_N(0Dn(Ke)KrPot0Ak~AlIkRkot2Kli$a:L-oRe[T_Tum1E,1B!a}'#Cib_Fic Fla%KlKr{Mokr!PreseRbyS#T-tiv3Kob,zKt|O^P]mSkSp+jV`]Vo/2AhaOuhoUhopis1Es0BroByt-C@t}ut DnesH+dHo^H,JemJn?Kl`KolaKtAzeDolObn(OgerieOzdSn(T Z(2B@}'noD-HaH'#S SnoT(0Oj?Or>2Nam :9O]gOnomie0EktronIpsa0AilIseO%P!ie2Izo^O/aOpejOs2EjEn%K<)Kymo0Ike)0FR&S]Zky3StOhOup(T!Ub.U/o)0AtO)Yz0IsOjivoOut0Bl.Boj}DinyDl!Dno)D|Jn(KejLin#L#LubMo+N [No,%RalR^RizontRkoRliv>RmonRn.RoskopR$voSpo^St.T'(U[UfUp!Us#V<2Ad[An?Av(Az^Bo+kD.D]D(N-Ob#Oma^OtOu^Oz@St#Ub(Yz!2B@(B~D[KotMrS aSto)0Ozd2Bn(D,ntGie&M&Sterik:2Yl#3Ned2O&0Uze0Un a0F-%Fla%KasoOva%Sp-%Tern{Vali^Ve$N)rRmarkRoSanSnoT#VD+Dn!_HlanKotL@L oMn(NomP?S{erV Zd>Zero3NakNdyNo/Sk,Sto)Trn?Zva3En|1Gurt5R):Bar{B_Bin{}&D{Did]HanJakJu)KaoKtusLam aLhotyLibrLn(Me,MkolivM&Ni[lNoeNtB#BlihaBylaC*rH=J@>KosKtejlLapsLe^LizeLoMandoMe)MikMn!aMo,MpasMun aN!N%ptNd?N>NfeseNgresN.NkursN)ktNzervaPan>PieP~Pr'#Rb_R-tSt#T_T+)T*lUk!Up_&Us-Uz]VbojZaZMe+cMivoOcanOkOni#Op OupaOv#T-Uh`]Up?Ut(Vin#Y/+Yp)Y$alYt2Dlan#FrJn(KlaLaj^Li/L#Lom{Ltu,NaPodivuRtRzV`]:B,d<})nDn(IkKom>M_aMpaN'#S?SoStu,Tin#V.3B#CkdyD@Dn?D'#Dv.G@^GieG,%H%Hk(H~KtvarNo/odNtil#P@#Pid]T`]T>TmoTokruhVhartV a%Vobok3B,}ot#DojedDsk(H'.Jav>L-M{#NieN#No+umStop`T.T|5Bi$aDivodGi#GopedKal aK{Mc|P!aPu/RdSosTrU^lUhU#Usk!V>3Tiv(1Cer&CiferMpSkSt,%0I%2RaRi#S.:DamD]Gi$rHagonJ{-J _J< aKakK'?Kr_aL[L.L|Lv?Min#Nd+NkoRn(SakrSkotSopu$T?Tri#Tur aZan>ZivoZl Zur#2Lo[0}anikD a%D'.LasaL*nNtol#TlaTo^TrZe,3G,%H~Hu+K.KrofonL@>Lim{rL(Mi#Nc'&Ni[rNom{Nul(S#StrX|2Ad(HaH'.OkS!Uv 1I/Ohem0BilCn(D_#Dl [HylaKroL-ulaM@t#Nar/aNoklN$rumNt|NzunSazSkytStTiva%T<#Ty#U/aUdr(Zai#Z-Zol2AmKevTvolaZ{Zut(0T _1DrcF]nL!MieN?S{Ta%ZeumZi#nt3Sliv>0Da:B*r!}yt!Da%Dbyt-DhozDobroDpisHlasHn!Hodi+H,d Iv aJedn*Ji$oJm=K]n Kon>Krm LevoMaz!Mluv Nom{rOkoOpakO$roP`!PevnoPln P~Pos+dPr(oRod RubyRy/]S` S-!S+poSt!TolikV@-Vr/VzdR&Ru[RysSahSluhaS)r!UvVazVin VodVyk+Yv!_Z<0AsElEn Hl` Ho)H,&It~0BojByt}odCiz Ebr!Esl!Evzd!EzvaH`%Hod J{JinudKazK*p LivLu#Ml#Oln(P`PisPl=PLivoLu[Mf+tMls-N@#Ni#N&N|N$voNtof+Pri#Rke)RodieR)Ru#Ry[Se#Siv aSt_#T@tTro&V*kZnehtZ*r-3C#DagogJs-K]LotonNal)Ndr-NzeRiskopRoStr(Tar^T?Tro+jVn.Xeso3Ani$aHaJav?K+KnikL.Ln(Lul#Nze)Pe)S!_Sto+Tev&Vn?V'ar2A%n)Ak!Am@Ane)A$i#At Avid]AzE/Em@oEn)EsEtivoEv_Iv!N NoO/aOd.Om[OutUkYn2Bav Byt}odC Ctiv>D!D%n Deps!Dh+dDiv Dkl`Dman DnikDo[Dpo,D,zD$!aDvodDzimEzieHan#Hnut#H'S*d SpoluS)vaSud-SypTahT#nT+skTom-T,vaTupaTvo,U#zUtoUzdroVahaVidlaVlakVozVr/V$!VykVzde/Zd,vZem-Zn!-ZAp<-AseAv^IncipKnoObud O%ntoOdejOfeseOh,Oj-tO]m Omi+Onik!Op`OrokOs[OtonOut-OvazS#v#St@Udk(UtV-VohOvodTruh0Actvo0Ber)}DlKav>Kl.Kr+LtMpaNcP@SaSin#St.T|Ty#3Rami^SkT_::C-}otDia%Dn?DonFtGbyKe)K'.M@oMp*/NdeRa/R aS'&StrTo+$Zan%Zid]3Ag|Ak%CeptDaktMizd!Mo)N #Rdin#San#T_ Z[Z@?0Or0H|1B,n#CeseD`]Dim@tD]Hn!Jm=Ke,K)Kun^KvojeM@oNoRvisS` Sho,SkokSl!St,SuvSyp!T[T.Tk!T~Trv!VerZ&m2O^R~0FonLn?R#Rot-RupTua%1AfandrAliskoAnz@AutEptikIcaL`[L@?LoLuzO[O#nOroRip)RzUp.V(Vr&0Abi#Adid]An.A$Avn(Ed|Ep>EvaEz.IbI&Izn?OnOup-OvoU/UhaUn%Up#Za0A,gdE)&Il$voL*vaOgR`RkRt#Ut-Ysl0AdAhaOb0Bo)}aD'#KolP#TvaUbojUc Ud%UhlasUl`Um,kUp,vaUsedUtokUvis{0Al'&As _IsLavOd-Oj@>OluOnzOvn!P@StUb1An?Ar(aAti#Av[EhnoEz#OdolaO+kOpaOrnoOup!Ra/ResRh~RomRu&Ud&Upn?VolYk0Bj-tBtropy}arD(KnoNd!N=Rik!aR'.0AhAl$voEtrAt[Az-Is+It-Obo^Odid]Or#Rab2Kav#KotN-N'>P!Pk(R'(S_T(:B+t#Bu+H*nJemnoJfunJgaJ Jn(Kti#Mh+MponNc|N>NkerPe)V@.Z!_3}ni#HdyKut.LefonMno)Nd@%Ni$aNU/l Uhl?UsV!2DyH~H(Nd,Ri$aR&jZemsko0ArohOr[Rd(Rz2GrKev:0Oh(OzeR!R*s-RusYt'&0HoTiv(0Iv 3R` 1Edn!I$ M=0Az!_Lidn Lon Otv Roj 0I%I)Ov 0Yv`]0Av IfR*s 1Al Oln Oz'#3D,v ElEn.L.N!:GonL/aL*nNaN^lNil#RanRhanyR|1ElkuHod0Ova0DroGe)%J%Lbl*dL{rhL _LmocLry[Nk'Ran^RzeS_#SkrzeSn?SpoduS)Ter.Ver#3B,%}rDeoh,D.D+LaN?S{Tal aZeZ #0Ezd0L`Us0Aj#AkAs>EvoHk(IvN'#Oup!1Uc|Uk0DaDiv(Doz&kD$voJ@skyJ&JskoLantL[L LnoSk'#Zid]Z'&0Ravo1Ab>A%tAhA)Ba}o+kH!StvaTu+0Ad T*p Tup0Ip4Bav Br!}|D!D,Fot H+d!H~Hod H,d Hub Jasn J{Jm=K]p Kon!L-!Maz!Mez Miz{Mys+tNe/!Nik!Nut P`!Pl! P,v Pu$ Raz R'n!Rv!Sl' SokoS)v Su~Syp!Tas Tes!Tr! Vi~Vol!Vrh_Zdob Zn!0AduBud }op DJ{Ji$ K+p!K*p Lep Mez Mot!Mys+tNe/!Nik!Pl! Poj Ps!Raz S)v Su~Taj Temn Tk~Ujm=Val Ve+tVin Vol!Vrt!Zvon 0Av RusuUd|Yt-1A+#ArmaAtn(IvoOb RojVihYm`]0L@.ManM.Pt!Z`uZdola2At Lt~Lubo#Ot' Ru[0MaMn?0Emn 0Lam!Oum!R!#Umav#0AtoEh#O[OmO$Ozvyk0Ap|ArAt-IjeIz{Ocn Odr!Rzl.Ut|0AkAl(Am@!Ovu0B,z Tav Ub-Ufa+0Lod Omal RavaR( Rud#Rvu1A^An C`]N (NoOv&Y/l Zav(1I/aR! 0B'.Br0Ed~EnkuEs_aOnR!Uk'odYk"; +const checksum = "0x25f44555f4af25b51a711136e1c7d6e50ce9f8917d39d6b1f076b2bb4d2fac1a"; + +export class LangCz extends WordlistOwl { + constructor() { super("cz", words, checksum); } +} + +export const langCz = new LangCz(); diff --git a/src.ts/wordlists/lang-en.ts b/src.ts/wordlists/lang-en.ts new file mode 100644 index 000000000..9fa27bc0d --- /dev/null +++ b/src.ts/wordlists/lang-en.ts @@ -0,0 +1,10 @@ +import { WordlistOwl } from "./wordlist-owl.js"; + +const words = "0erleonalorenseinceregesticitStanvetearctssi#ch2Athck&tneLl0And#Il.yLeOutO=S|S%b/ra@SurdU'0Ce[Cid|CountCu'Hie=IdOu,-Qui*Ro[TT]T%T*[Tu$0AptDD-tD*[Ju,M.UltV<)Vi)0Rob-0FairF%dRaid0A(EEntRee0Ead0MRRp%tS!_rmBumCoholErtI&LLeyLowMo,O}PhaReadySoT Ways0A>urAz(gOngOuntU'd0Aly,Ch%Ci|G G!GryIm$K!Noun)Nu$O` Sw T&naTiqueXietyY1ArtOlogyPe?P!Pro=Ril1ChCt-EaEnaGueMMedM%MyOundR<+Re,Ri=RowTTefa@Ti,Tw%k0KPe@SaultSetSi,SumeThma0H!>OmTa{T&dT.udeTra@0Ct]D.Gu,NtTh%ToTumn0Era+OcadoOid0AkeA*AyEsomeFulKw?d0Is:ByChel%C#D+GL<)Lc#y~MbooN_{Ad!AftAmA}AshAt AwlAzyEamEd.EekEwI{etImeIspIt-OpO[Ou^OwdUci$UelUi'Umb!Un^UshYY,$2BeLtu*PPbo?dRiousRr|Rta(R=Sh]/omTe3C!:DMa+MpN)Ng R(gShUght WnY3AlBa>BrisCadeCemb CideCl(eC%a>C*a'ErF&'F(eFyG*eLayLiv M3AgramAlAm#dAryCeE'lEtFf G.$Gn.yLemmaNn NosaurRe@RtSag*eScov Sea'ShSmi[S%d Splay/<)V tVideV%)Zzy5Ct%Cum|G~Lph(Ma(Na>NkeyN%OrSeUb!Ve_ftAg#AmaA,-AwEamE[IftIllInkIpI=OpUmY2CkMbNeR(g/T^Ty1Arf1Nam-:G G!RlyRnR`Sily/Sy1HoOlogyOnomy0GeItUca>1F%t0G1GhtTh 2BowD E@r-EgSe0B?kBodyBra)Er+Ot]PloyPow Pty0Ab!A@DD![D%'EmyErgyF%)Ga+G(eH<)JoyLi,OughR-hRollSu*T Ti*TryVelope1Isode0U$Uip0AA'OdeOs]R%Upt0CapeSayS&)Ta>0Ern$H-s1Id&)IlOkeOl=1A@Amp!Ce[Ch<+C.eCludeCu'Ecu>Erci'Hau,Hib.I!I,ItOt-PM&'Mu}Pa@Po'Pro=Pul'0ChCludeComeC*a'DexD-a>Do%Du,ryFN Noc|PutQuirySSue0Em1Ory:CketGu?RZz3AlousAns~yWel9BInKeUr}yY5D+I)MpNg!Ni%Nk/:Ng?oo3EnEpT^upY3CkDD}yNdNgdomSsTT^&TeTt&Wi4EeIfeO{Ow:BBelB%Dd DyKeMpNgua+PtopR+T T(UghUndryVaWWnWsu.Y Zy3Ad AfArnA=Ctu*FtGG$G&dIsu*M#NdNg`NsOp?dSs#Tt Vel3ArB tyBr?yC&'FeFtGhtKeMbM.NkOnQuid/Tt!VeZ?d5AdAnB, C$CkG-NelyNgOpTt yUdUn+VeY$5CkyGga+Mb N?N^Xury3R-s:Ch(eDG-G}tIdIlInJ%KeMm$NNa+Nda>NgoNs]Nu$P!Rb!R^Rg(R(eRketRria+SkSs/ T^T i$ThTrixTt XimumZe3AdowAnAsu*AtCh<-D$DiaLodyLtMb M%yNt]NuRcyR+R.RryShSsa+T$Thod3Dd!DnightLk~]M-NdNimumN%Nu>Rac!Rr%S ySs/akeXXedXtu*5Bi!DelDifyMM|N.%NkeyN, N`OnR$ReRn(gSqu.oTh T]T%Unta(U'VeVie5ChFf(LeLtiplySc!SeumShroomS-/Tu$3Self/ yTh:I=MePk(Rrow/yT]Tu*3ArCkEdGati=G!@I` PhewR=/TTw%kUtr$V WsXt3CeGht5B!I'M(eeOd!Rm$R`SeTab!TeTh(gTi)VelW5C!?Mb R'T:K0EyJe@Li+Scu*S =Ta(Vious0CurEAyEa'Ed+U{UgUn+2EmEtIntL?LeLi)NdNyOlPul?Rt]S.]Ssib!/TatoTt yV tyWd W _@i)Ai'Ed-tEf Epa*Es|EttyEv|I)IdeIm?yIntI%.yIs#Iva>IzeOb!mO)[Odu)Of.OgramOje@Omo>OofOp tyOsp O>@OudOvide2Bl-Dd(g~LpL'Mpk(N^PilPpyR^a'R.yRpo'R'ShTZz!3Ramid:99Al.yAntumArt E,]I{ItIzO>:Bb.Cco#CeCkD?DioIlInI'~yMpN^NdomN+PidReTeTh V&WZ%3AdyAlAs#BelBuildC$lCei=CipeC%dCyc!Du)F!@F%mFu'G]G*tGul?Je@LaxLea'LiefLyMa(Memb M(dMo=Nd NewNtOp&PairPeatPla)P%tQui*ScueSemb!Si,Sour)Sp#'SultTi*T*atTurnUn]Ve$ViewW?d2Y`m0BBb#CeChDeD+F!GhtGidNgOtPp!SkTu$V$V 5AdA,BotBu,CketM<)OfOkieOmSeTa>UghUndU>Y$5Bb DeGLeNNwayR$:DDd!D}[FeIlLadLm#L#LtLu>MeMp!NdTisfyToshiU)Usa+VeY1A!AnA*Att E}HemeHoolI&)I[%sOrp]OutRapRe&RiptRub1AAr^As#AtC#dC*tCt]Cur.yEdEkGm|Le@~M(?Ni%N'Nt&)RiesRvi)Ss]Tt!TupV&_dowAftAllowA*EdEllEriffIeldIftI}IpIv O{OeOotOpOrtOuld O=RimpRugUff!Y0Bl(gCkDeE+GhtGnL|Lk~yLv Mil?Mp!N)NgR&/ Tua>XZe1A>Et^IIllInIrtUll0AbAmEepEnd I)IdeIghtImOgAyEakEelEmEpE*oI{IllIngO{Oma^O}OolOryO=Ra>gyReetRikeR#gRugg!Ud|UffUmb!Y!0Bje@Bm.BwayC)[ChDd&Ff G?G+,ItMm NNnyN'tP PplyP*meReRfa)R+Rpri'RroundR=ySpe@/a(1AllowAmpApArmE?EetIftImIngIt^Ord1MbolMptomRup/em:B!Ck!GIlL|LkNkPeR+tSk/eTtooXi3A^Am~NNGradeHoldOnP Set1BOng::Rd3Ar~ow9UUngU`:3BraRo9NeO"; +const checksum = "0x3c8acc1e7b08d8e76f9fda015ef48dc8c710a73cb7e0f77b2c18a9b5a7adde60"; + +export class LangEn extends WordlistOwl { + constructor() { super("en", words, checksum); } +} + +export const langEn = new LangEn(); diff --git a/src.ts/wordlists/lang-es.ts b/src.ts/wordlists/lang-es.ts new file mode 100644 index 000000000..e2fa5ea9b --- /dev/null +++ b/src.ts/wordlists/lang-es.ts @@ -0,0 +1,11 @@ +import { WordlistOwlA } from "./wordlist-owla.js"; + +const words = "0arertoiotadonoaRteirroenaNonaLsolocoiliaralaorrenadaChoN$n0A>Dom,EjaI!#Oga&O'Or#RazoR*Ue=U<0Ab Adem@CeLe%OmoRa!RozUn0DazD$GeLaM,#S,)T^0AlAnceA+EEl]`E`EstruzI.I<2ErU{U'0Af[nArO)Uc Uf_Ul:BaB^|eH@IleJ Lanz/c.LdeMbuN>Nd-oRb(>RnizR+Scu]S#nSu[Tal]T!@T*Tu%UlZ 3BeBid/=S SoSt@3|oEnNgo2An>OqueUsa2ABi`BoCaCi`DaDegaIn//!oLsaMb-{dNi#N}saiRdeRr SqueTeTinVe{Zal2AvoAzoEchaEveIl=In>IsaOcaOmaOnceO)UjaUs>U#2CeoCleE'EyFan{F.HoIt_L#Rbuj(l(+Sc TacaZ.:Bal=BezaBi`B[CaoDav!D,aErFeI{ImanJaJ.LLam Lc$L&Li{dLleLm/^LvoMaMb$Mel=Mi'Mp}c!Nd?Nel-gu+Nic-#N-.ObaOsPazPi%nPo)Pt Puch((b.RcelRe%Rg(i'RneRpe%R+R%SaS>S!oSpaS#rT^ceT_U{lUsaZo3Bol]D!D+Ld/eb_LoAmpuAnc]ApaAr]I>Is)IvoOqueOzaUle%Up 0Cl.EgoE=EnEr#F[G +M->NeN%P_sR>Rue]SneTaU{d2Am^AnA+AseAveI,)ImaInica2B_Cc~|i'Ci`CoDigoDoF_G!He)JinJoL/ch/eg$Lg Lin/l LmoLum`Mba)M!Mi{Mo&Mpr-deNej}g-oc!Nsej}t PaPi(az.Rba%RchoR&nR.(r!S!SmosS%2AneoAt!E Ec!Ei&EmaIaIm,Ip%IsisOmoOnicaOque%U&Uz2Ad+Ar#At+BoBr*| aEl=En#Er{Es%EvaId Lebr/p/#Mb_Mpl*N-e%O%P.Pul( R$Se'Sf[zVaVi'5BleCeL^Ming}N Ra&Rm*RAu%EchaOrO%U*UjoU^2B@CaGa%G.L$Lle#N&Rm(+Rtun(z SaTo2AcaA'AsaAtisAveIe%Il=IpeIsI#OG Gu!aJaMb_Ng}^Nr((mig('St?Yo5E>ElgaEr%ENgl-$Nt Pit!R S#V,?Zg :7Lo5A]:B$C$C[DoD+nG #GrimaGu`I>M!Mi`Mp --ch-gos%NzaPizRgoRvaStimaTaTexT*U_lV Zo3AlCc~|eC#rErG~Gumb_Ja'Ngu-#NaOnOp &S~TalT[VeY,{3B!%dB+C^D!Di EnzoGaG!oMaMi)M.Mp$NceN&Ne-go)N}t!`Qui&SoS%T!aT$T+2AgaAmaAn#AveEg En Ev Or Ov!Uv@2BoC~CoCu[GicaG+MbrizM}jaTe5|aC*G J}-esPaSt+ToZ:Ce%|oD!aD_Du+Est+F@G@GoIzL{dLe%Ll/oMaMboMutN>N&Nej Ng-iquiNj N}Re(f?Rg,Ri&RmolR+nR)sRzoSaSc aSivoT T!@TizTrizXimoY^Z^ca3|aDal]D$Du]J?]J^L,/.M^i-^NsajeN)NuRca&R,gueRi#SS.TaT!To&T+Zc]3E&ElEmb+G/Lag+Lit Ll.M}-!}im}u#OpeR SaS!@S?SmoTadTo5|?aC~DaDe=HoJ LdeL!Li'M,#Mi- c-ed-j-#NoRad(d!Re'R*R+Rs(%lScaStr TivoV!V?Zo5|oD EbleE]Er)Est[G_J!L/e%L%N&Nec(alRoScu=SeoSgoSicaS=:C C~D IpeRanj(izRr SalTalTivoTu[lUseaValVeVi{d3C$Ct G Goc$G+OnRv$ToUt+V V!a3|oDoEb]E#NezNoTi&Vel5Bleza|eMin(i(m()TaTic@Va#Ve]V$5BeCaCleoD?=DoE[EveEzLoM!oTr@:Sis0EC~E[In On!T TicaUes#1Ac~A&rAlBi%CaD,EjaGa'G@Gul=I,)Ig,Il]OQues%Uga0Ad@Cu+Ez'OT[0O'Ro1EjaU=1I&Ige'0En)0O':C#D_El]Gi`GoIsJ oLabr/>Le%Li&Lm/om/p NNalNi>Nt!-ue=PaPelP?]Que)R Rcel(edR*RoRpa&RqueR[foR)S SeoS~SoS%TaT$Tr@UsaU%VoYa<3A#nCa&C!a|oDalD*G IneL L{'Le/ig+LlejoLoLuc--s N.OnOrPi'Que'R(ch(d!Rez(f?Ri>Rl(mizEgun%Em$EnsaE|!oD^Eb=Er%Es#Lg/*Lm.LpoLrNd*N%P #Pet*PoN{PaP!oSaScaSt+T 5BiB^DoE{G*I&In/e%LoMboM^Ptu[TaTi`:Ba&B!B$BleC GazG[&L/&L!oL*Lm.L.Ls/#LudLv Mb-c~Ndi-e Ng_Ni{dN}#PoQueRdin()nSt_TanU`Xof.3Cc~CoC_#C%DGu*IsL=LvaMa`M?l-d-Re'Rg*S#T?:Ba>BiqueB]BuCoC#JoL L>L,#Ll/.Ma'Mb^Ng}quePaPe)P@P.Qu?l(deRe(if(je%RotR+R%TuajeU+ZaZ.3At+|oC]CnicaJa&J!Ji&L/efo'MaM^Mp=NazNd!N!NisNRmi'Rnur(+rSisSo+StigoT!aX#Z3B$Bu+nEmpoEn{Er[EPoR(.TanT!eTu=Za5Al]B?=C Ci'DoG/&M N}#P PeQueRaxR!oRm,%RneoRoRpe&R_RS!Xi>2AbajoAc#rA!Afi>AgoAjeAmoAnceA#AumaAz EbolEguaEin%EnEp EsIbuIgoIpaIs)IunfoOfeoOmpaOn>OpaO)OzoU>Ue'Ufa2B!@BoEr#MbaM^NelNic(bin(ismoR'T^:0Ic 9C!a0B[l0I{dIrIv! = null; + +function hex(word: string) { + return hexlify(toUtf8Bytes(word)); +} + +const KiYoKu = "0xe3818de38284e3818f"; +const KyoKu = "0xe3818de38283e3818f" + +function toString(data: Array): string { + return toUtf8String(new Uint8Array(data)); +} + +function loadWords(): Array { + if (_wordlist !== null) { return _wordlist; } + + const wordlist = []; + + // Transforms for normalizing (sort is a not quite UTF-8) + const transform: { [key: string]: string | boolean } = {}; + + // Delete the diacritic marks + transform[toString([227, 130, 154])] = false; + transform[toString([227, 130, 153])] = false; + + // Some simple transforms that sort out most of the order + transform[toString([227, 130, 133])] = toString([227, 130, 134]); + transform[toString([227, 129, 163])] = toString([227, 129, 164]); + transform[toString([227, 130, 131])] = toString([227, 130, 132]); + transform[toString([227, 130, 135])] = toString([227, 130, 136]); + + + // Normalize words using the transform + function normalize(word: string) { + let result = ""; + for (let i = 0; i < word.length; i++) { + let kana = word[i]; + const target = transform[kana]; + if (target === false) { continue; } + if (target) { kana = target; } + result += kana; + } + return result; + } + + // Sort how the Japanese list is sorted + function sortJapanese(a: string, b: string) { + a = normalize(a); + b = normalize(b); + if (a < b) { return -1; } + if (a > b) { return 1; } + return 0; + } + + // Load all the words + for (let length = 3; length <= 9; length++) { + const d = data[length - 3]; + for (let offset = 0; offset < d.length; offset += length) { + const word = []; + for (let i = 0; i < length; i++) { + const k = mapping.indexOf(d[offset + i]); + word.push(227); + word.push((k & 0x40) ? 130: 129); + word.push((k & 0x3f) + 128); + } + wordlist.push(toString(word)); + } + } + wordlist.sort(sortJapanese); + + // For some reason kyoku and kiyoku are flipped in node (!!). + // The order SHOULD be: + // - kyoku + // - kiyoku + + // This should ignore "if", but that doesn't work here?? + /* c8 ignore start */ + if (hex(wordlist[442]) === KiYoKu && hex(wordlist[443]) === KyoKu) { + const tmp = wordlist[442]; + wordlist[442] = wordlist[443]; + wordlist[443] = tmp; + } + /* c8 ignore stop */ + + // Verify the computed list matches the official list + /* istanbul ignore if */ + const checksum = id(wordlist.join("\n") + "\n"); + /* c8 ignore start */ + if (checksum !== "0xcb36b09e6baa935787fd762ce65e80b0c6a8dabdfbc3a7f86ac0e2c4fd111600") { + throw new Error("BIP39 Wordlist for ja (Japanese) FAILED"); + } + /* c8 ignore stop */ + + _wordlist = wordlist; + + return wordlist; +} + +class LangJa extends Wordlist { + constructor() { super("ja"); } + + getWord(index: number): string { + const words = loadWords(); + if (index < 0 || index >= words.length) { + logger.throwArgumentError(`invalid word index: ${ index }`, "index", index); + } + return words[index]; + } + + getWordIndex(word: string): number { + return loadWords().indexOf(word); + } + + split(mnemonic: string): Array { + //logger.assertNormalize(); + return mnemonic.split(/(?:\u3000| )+/g); + } + + join(words: Array): string { + return words.join("\u3000"); + } +} + +export const langJa = new LangJa(); diff --git a/src.ts/wordlists/lang-ko.ts b/src.ts/wordlists/lang-ko.ts new file mode 100644 index 000000000..bcefa95a6 --- /dev/null +++ b/src.ts/wordlists/lang-ko.ts @@ -0,0 +1,83 @@ +import { id } from "../hash/id.js"; +import { logger, toUtf8String } from "../utils/index.js"; + +import { Wordlist } from "./wordlist.js"; + + +const data = [ + "OYAa", + "ATAZoATBl3ATCTrATCl8ATDloATGg3ATHT8ATJT8ATJl3ATLlvATLn4ATMT8ATMX8ATMboATMgoAToLbAToMTATrHgATvHnAT3AnAT3JbAT3MTAT8DbAT8JTAT8LmAT8MYAT8MbAT#LnAUHT8AUHZvAUJXrAUJX8AULnrAXJnvAXLUoAXLgvAXMn6AXRg3AXrMbAX3JTAX3QbAYLn3AZLgvAZrSUAZvAcAZ8AaAZ8AbAZ8AnAZ8HnAZ8LgAZ8MYAZ8MgAZ8OnAaAboAaDTrAaFTrAaJTrAaJboAaLVoAaMXvAaOl8AaSeoAbAUoAbAg8AbAl4AbGnrAbMT8AbMXrAbMn4AbQb8AbSV8AbvRlAb8AUAb8AnAb8HgAb8JTAb8NTAb8RbAcGboAcLnvAcMT8AcMX8AcSToAcrAaAcrFnAc8AbAc8MgAfGgrAfHboAfJnvAfLV8AfLkoAfMT8AfMnoAfQb8AfScrAfSgrAgAZ8AgFl3AgGX8AgHZvAgHgrAgJXoAgJX8AgJboAgLZoAgLn4AgOX8AgoATAgoAnAgoCUAgoJgAgoLXAgoMYAgoSeAgrDUAgrJTAhrFnAhrLjAhrQgAjAgoAjJnrAkMX8AkOnoAlCTvAlCV8AlClvAlFg4AlFl6AlFn3AloSnAlrAXAlrAfAlrFUAlrFbAlrGgAlrOXAlvKnAlvMTAl3AbAl3MnAnATrAnAcrAnCZ3AnCl8AnDg8AnFboAnFl3AnHX4AnHbrAnHgrAnIl3AnJgvAnLXoAnLX4AnLbrAnLgrAnLhrAnMXoAnMgrAnOn3AnSbrAnSeoAnvLnAn3OnCTGgvCTSlvCTvAUCTvKnCTvNTCT3CZCT3GUCT3MTCT8HnCUCZrCULf8CULnvCU3HnCU3JUCY6NUCbDb8CbFZoCbLnrCboOTCboScCbrFnCbvLnCb8AgCb8HgCb$LnCkLfoClBn3CloDUDTHT8DTLl3DTSU8DTrAaDTrLXDTrLjDTrOYDTrOgDTvFXDTvFnDT3HUDT3LfDUCT9DUDT4DUFVoDUFV8DUFkoDUGgrDUJnrDULl8DUMT8DUMXrDUMX4DUMg8DUOUoDUOgvDUOg8DUSToDUSZ8DbDXoDbDgoDbGT8DbJn3DbLg3DbLn4DbMXrDbMg8DbOToDboJXGTClvGTDT8GTFZrGTLVoGTLlvGTLl3GTMg8GTOTvGTSlrGToCUGTrDgGTrJYGTrScGTtLnGTvAnGTvQgGUCZrGUDTvGUFZoGUHXrGULnvGUMT8GUoMgGXoLnGXrMXGXrMnGXvFnGYLnvGZOnvGZvOnGZ8LaGZ8LmGbAl3GbDYvGbDlrGbHX3GbJl4GbLV8GbLn3GbMn4GboJTGboRfGbvFUGb3GUGb4JnGgDX3GgFl$GgJlrGgLX6GgLZoGgLf8GgOXoGgrAgGgrJXGgrMYGgrScGgvATGgvOYGnAgoGnJgvGnLZoGnLg3GnLnrGnQn8GnSbrGnrMgHTClvHTDToHTFT3HTQT8HToJTHToJgHTrDUHTrMnHTvFYHTvRfHT8MnHT8SUHUAZ8HUBb4HUDTvHUoMYHXFl6HXJX6HXQlrHXrAUHXrMnHXrSbHXvFYHXvKXHX3LjHX3MeHYvQlHZrScHZvDbHbAcrHbFT3HbFl3HbJT8HbLTrHbMT8HbMXrHbMbrHbQb8HbSX3HboDbHboJTHbrFUHbrHgHbrJTHb8JTHb8MnHb8QgHgAlrHgDT3HgGgrHgHgrHgJTrHgJT8HgLX@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", + "ATLnDlATrAZoATrJX4ATrMT8ATrMX4ATrRTrATvDl8ATvJUoATvMl8AT3AToAT3MX8AT8CT3AT8DT8AT8HZrAT8HgoAUAgFnAUCTFnAXoMX8AXrAT8AXrGgvAXrJXvAXrOgoAXvLl3AZvAgoAZvFbrAZvJXoAZvJl8AZvJn3AZvMX8AZvSbrAZ8FZoAZ8LZ8AZ8MU8AZ8OTvAZ8SV8AZ8SX3AbAgFZAboJnoAbvGboAb8ATrAb8AZoAb8AgrAb8Al4Ab8Db8Ab8JnoAb8LX4Ab8LZrAb8LhrAb8MT8Ab8OUoAb8Qb8Ab8ST8AcrAUoAcrAc8AcrCZ3AcrFT3AcrFZrAcrJl4AcrJn3AcrMX3AcrOTvAc8AZ8Ac8MT8AfAcJXAgoFn4AgoGgvAgoGnrAgoLc8AgoMXoAgrLnrAkrSZ8AlFXCTAloHboAlrHbrAlrLhrAlrLkoAl3CZrAl3LUoAl3LZrAnrAl4AnrMT8An3HT4BT3IToBX4MnvBb!Ln$CTGXMnCToLZ4CTrHT8CT3JTrCT3RZrCT#GTvCU6GgvCU8Db8CU8GZrCU8HT8CboLl3CbrGgrCbrMU8Cb8DT3Cb8GnrCb8LX4Cb8MT8Cb8ObrCgrGgvCgrKX4Cl8FZoDTrAbvDTrDboDTrGT6DTrJgrDTrMX3DTrRZrDTrRg8DTvAVvDTvFZoDT3DT8DT3Ln3DT4HZrDT4MT8DT8AlrDT8MT8DUAkGbDUDbJnDYLnQlDbDUOYDbMTAnDbMXSnDboAT3DboFn4DboLnvDj6JTrGTCgFTGTGgFnGTJTMnGTLnPlGToJT8GTrCT3GTrLVoGTrLnvGTrMX3GTrMboGTvKl3GZClFnGZrDT3GZ8DTrGZ8FZ8GZ8MXvGZ8On8GZ8ST3GbCnQXGbMbFnGboFboGboJg3GboMXoGb3JTvGb3JboGb3Mn6Gb3Qb8GgDXLjGgMnAUGgrDloGgrHX4GgrSToGgvAXrGgvAZvGgvFbrGgvLl3GgvMnvGnDnLXGnrATrGnrMboGnuLl3HTATMnHTAgCnHTCTCTHTrGTvHTrHTvHTrJX8HTrLl8HTrMT8HTrMgoHTrOTrHTuOn3HTvAZrHTvDTvHTvGboHTvJU8HTvLl3HTvMXrHTvQb4HT4GT6HT4JT8HT4Jb#HT8Al3HT8GZrHT8GgrHT8HX4HT8Jb8HT8JnoHT8LTrHT8LgvHT8SToHT8SV8HUoJUoHUoJX8HUoLnrHXrLZoHXvAl3HX3LnrHX4FkvHX4LhrHX4MXoHX4OnoHZrAZ8HZrDb8HZrGZ8HZrJnrHZvGZ8HZvLnvHZ8JnvHZ8LhrHbCXJlHbMTAnHboJl4HbpLl3HbrJX8HbrLnrHbrMnvHbvRYrHgoSTrHgrFV8HgrGZ8HgrJXoHgrRnvHgvBb!HgvGTrHgvHX4HgvHn!HgvLTrHgvSU8HnDnLbHnFbJbHnvDn8Hn6GgvHn!BTvJTCTLnJTQgFnJTrAnvJTrLX4JTrOUoJTvFn3JTvLnrJTvNToJT3AgoJT3Jn4JT3LhvJT3ObrJT8AcrJT8Al3JT8JT8JT8JnoJT8LX4JT8LnrJT8MX3JT8Rg3JT8Sc8JUoBTvJU8AToJU8GZ8JU8GgvJU8JTrJU8JXrJU8JnrJU8LnvJU8ScvJXHnJlJXrGgvJXrJU8JXrLhrJXrMT8JXrMXrJXrQUoJXvCTvJXvGZ8JXvGgrJXvQT8JX8Ab8JX8DT8JX8GZ8JX8HZvJX8LnrJX8MT8JX8MXoJX8MnvJX8ST3JYGnCTJbAkGbJbCTAnJbLTAcJboDT3JboLb6JbrAnvJbrCn3JbrDl8JbrGboJbrIZoJbrJnvJbrMnvJbrQb4Jb8RZrJeAbAnJgJnFbJgScAnJgrATrJgvHZ8JgvMn4JlJlFbJlLiQXJlLjOnJlRbOlJlvNXoJlvRl3Jl4AcrJl8AUoJl8MnrJnFnMlJnHgGbJnoDT8JnoFV8JnoGgvJnoIT8JnoQToJnoRg3JnrCZ3JnrGgrJnrHTvJnrLf8JnrOX8JnvAT3JnvFZoJnvGT8JnvJl4JnvMT8JnvMX8JnvOXrJnvPX6JnvSX3JnvSZrJn3MT8Jn3MX8Jn3RTrLTATKnLTJnLTLTMXKnLTRTQlLToGb8LTrAZ8LTrCZ8LTrDb8LTrHT8LT3PX6LT4FZoLT$CTvLT$GgrLUvHX3LVoATrLVoAgoLVoJboLVoMX3LVoRg3LV8CZ3LV8FZoLV8GTvLXrDXoLXrFbrLXvAgvLXvFlrLXvLl3LXvRn6LX4Mb8LX8GT8LYCXMnLYrMnrLZoSTvLZrAZvLZrAloLZrFToLZrJXvLZrJboLZrJl4LZrLnrLZrMT8LZrOgvLZrRnvLZrST4LZvMX8LZvSlvLZ8AgoLZ8CT3LZ8JT8LZ8LV8LZ8LZoLZ8Lg8LZ8SV8LZ8SbrLZ$HT8LZ$Mn4La6CTvLbFbMnLbRYFTLbSnFZLboJT8LbrAT9LbrGb3LbrQb8LcrJX8LcrMXrLerHTvLerJbrLerNboLgrDb8LgrGZ8LgrHTrLgrMXrLgrSU8LgvJTrLgvLl3Lg6Ll3LhrLnrLhrMT8LhvAl4LiLnQXLkoAgrLkoJT8LkoJn4LlrSU8Ll3FZoLl3HTrLl3JX8Ll3JnoLl3LToLmLeFbLnDUFbLnLVAnLnrATrLnrAZoLnrAb8LnrAlrLnrGgvLnrJU8LnrLZrLnrLhrLnrMb8LnrOXrLnrSZ8LnvAb4LnvDTrLnvDl8LnvHTrLnvHbrLnvJT8LnvJU8LnvJbrLnvLhvLnvMX8LnvMb8LnvNnoLnvSU8Ln3Al3Ln4FZoLn4GT6Ln4JgvLn4LhrLn4MT8Ln4SToMToCZrMToJX8MToLX4MToLf8MToRg3MTrEloMTvGb6MT3BTrMT3Lb6MT8AcrMT8AgrMT8GZrMT8JnoMT8LnrMT8MX3MUOUAnMXAbFnMXoAloMXoJX8MXoLf8MXoLl8MXrAb8MXrDTvMXrGT8MXrGgrMXrHTrMXrLf8MXrMU8MXrOXvMXrQb8MXvGT8MXvHTrMXvLVoMX3AX3MX3Jn3MX3LhrMX3MX3MX4AlrMX4OboMX8GTvMX8GZrMX8GgrMX8JT8MX8JX8MX8LhrMX8MT8MYDUFbMYMgDbMbGnFfMbvLX4MbvLl3Mb8Mb8Mb8ST4MgGXCnMg8ATrMg8AgoMg8CZrMg8DTrMg8DboMg8HTrMg8JgrMg8LT8MloJXoMl8AhrMl8JT8MnLgAUMnoJXrMnoLX4MnoLhrMnoMT8MnrAl4MnrDb8MnrOTvMnrOgvMnrQb8MnrSU8MnvGgrMnvHZ8Mn3MToMn4DTrMn4LTrMn4Mg8NnBXAnOTFTFnOToAToOTrGgvOTrJX8OT3JXoOT6MTrOT8GgrOT8HTpOT8MToOUoHT8OUoJT8OUoLn3OXrAgoOXrDg8OXrMT8OXvSToOX6CTvOX8CZrOX8OgrOb6HgvOb8AToOb8MT8OcvLZ8OgvAlrOgvHTvOgvJTrOgvJnrOgvLZrOgvLn4OgvMT8OgvRTrOg8AZoOg8DbvOnrOXoOnvJn4OnvLhvOnvRTrOn3GgoOn3JnvOn6JbvOn8OTrPTGYFTPbBnFnPbGnDnPgDYQTPlrAnvPlrETvPlrLnvPlrMXvPlvFX4QTMTAnQTrJU8QYCnJlQYJlQlQbGTQbQb8JnrQb8LZoQb8LnvQb8MT8Qb8Ml8Qb8ST4QloAl4QloHZvQloJX8QloMn8QnJZOlRTrAZvRTrDTrRTvJn4RTvLhvRT4Jb8RZrAZrRZ8AkrRZ8JU8RZ8LV8RZ8LnvRbJlQXRg3GboRg3MnvRg8AZ8Rg8JboRg8Jl4RnLTCbRnvFl3RnvQb8SToAl4SToCZrSToFZoSToHXrSToJU8SToJgvSToJl4SToLhrSToMX3STrAlvSTrCT9STrCgrSTrGgrSTrHXrSTrHboSTrJnoSTrNboSTvLnrST4AZoST8Ab8ST8JT8SUoJn3SU6HZ#SU6JTvSU8Db8SU8HboSU8LgrSV8JT8SZrAcrSZrAl3SZrJT8SZrJnvSZrMT8SZvLUoSZ4FZoSZ8JnoSZ8RZrScoLnrScoMT8ScoMX8ScrAT4ScrAZ8ScrLZ8ScrLkvScvDb8ScvLf8ScvNToSgrFZrShvKnrSloHUoSloLnrSlrMXoSl8HgrSmrJUoSn3BX6", + "ATFlOn3ATLgrDYAT4MTAnAT8LTMnAYJnRTrAbGgJnrAbLV8LnAbvNTAnAeFbLg3AgOYMXoAlQbFboAnDboAfAnJgoJTBToDgAnBUJbAl3BboDUAnCTDlvLnCTFTrSnCYoQTLnDTwAbAnDUDTrSnDUHgHgrDX8LXFnDbJXAcrETvLTLnGTFTQbrGTMnGToGT3DUFbGUJlPX3GbQg8LnGboJbFnGb3GgAYGgAg8ScGgMbAXrGgvAbAnGnJTLnvGnvATFgHTDT6ATHTrDlJnHYLnMn8HZrSbJTHZ8LTFnHbFTJUoHgSeMT8HgrLjAnHgvAbAnHlFUrDlHnDgvAnHnHTFT3HnQTGnrJTAaMXvJTGbCn3JTOgrAnJXvAXMnJbMg8SnJbMnRg3Jb8LTMnJnAl3OnJnGYrQlJnJlQY3LTDlCn3LTJjLg3LTLgvFXLTMg3GTLV8HUOgLXFZLg3LXNXrMnLX8QXFnLX9AlMYLYLXPXrLZAbJU8LZDUJU8LZMXrSnLZ$AgFnLaPXrDULbFYrMnLbMn8LXLboJgJgLeFbLg3LgLZrSnLgOYAgoLhrRnJlLkCTrSnLkOnLhrLnFX%AYLnFZoJXLnHTvJbLnLloAbMTATLf8MTHgJn3MTMXrAXMT3MTFnMUITvFnMXFX%AYMXMXvFbMXrFTDbMYAcMX3MbLf8SnMb8JbFnMgMXrMTMgvAXFnMgvGgCmMnAloSnMnFnJTrOXvMXSnOX8HTMnObJT8ScObLZFl3ObMXCZoPTLgrQXPUFnoQXPU3RXJlPX3RkQXPbrJXQlPlrJbFnQUAhrDbQXGnCXvQYLnHlvQbLfLnvRTOgvJbRXJYrQlRYLnrQlRbLnrQlRlFT8JlRlFnrQXSTClCn3STHTrAnSTLZQlrSTMnGTrSToHgGbSTrGTDnSTvGXCnST3HgFbSU3HXAXSbAnJn3SbFT8LnScLfLnv", + "AT3JgJX8AT8FZoSnAT8JgFV8AT8LhrDbAZ8JT8DbAb8GgLhrAb8SkLnvAe8MT8SnAlMYJXLVAl3GYDTvAl3LfLnvBUDTvLl3CTOn3HTrCT3DUGgrCU8MT8AbCbFTrJUoCgrDb8MTDTLV8JX8DTLnLXQlDT8LZrSnDUQb8FZ8DUST4JnvDb8ScOUoDj6GbJl4GTLfCYMlGToAXvFnGboAXvLnGgAcrJn3GgvFnSToGnLf8JnvGn#HTDToHTLnFXJlHTvATFToHTvHTDToHTvMTAgoHT3STClvHT4AlFl6HT8HTDToHUoDgJTrHUoScMX3HbRZrMXoHboJg8LTHgDb8JTrHgMToLf8HgvLnLnoHnHn3HT4Hn6MgvAnJTJU8ScvJT3AaQT8JT8HTrAnJXrRg8AnJbAloMXoJbrATFToJbvMnoSnJgDb6GgvJgDb8MXoJgSX3JU8JguATFToJlPYLnQlJlQkDnLbJlQlFYJlJl8Lf8OTJnCTFnLbJnLTHXMnJnLXGXCnJnoFfRg3JnrMYRg3Jn3HgFl3KT8Dg8LnLTRlFnPTLTvPbLbvLVoSbrCZLXMY6HT3LXNU7DlrLXNXDTATLX8DX8LnLZDb8JU8LZMnoLhrLZSToJU8LZrLaLnrLZvJn3SnLZ8LhrSnLaJnoMT8LbFlrHTvLbrFTLnrLbvATLlvLb6OTFn3LcLnJZOlLeAT6Mn4LeJT3ObrLg6LXFlrLhrJg8LnLhvDlPX4LhvLfLnvLj6JTFT3LnFbrMXoLnQluCTvLnrQXCY6LnvLfLnvLnvMgLnvLnvSeLf8MTMbrJn3MT3JgST3MT8AnATrMT8LULnrMUMToCZrMUScvLf8MXoDT8SnMX6ATFToMX8AXMT8MX8FkMT8MX8HTrDUMX8ScoSnMYJT6CTvMgAcrMXoMg8SToAfMlvAXLg3MnFl3AnvOT3AnFl3OUoATHT8OU3RnLXrOXrOXrSnObPbvFn6Og8HgrSnOg8OX8DbPTvAgoJgPU3RYLnrPXrDnJZrPb8CTGgvPlrLTDlvPlvFUJnoQUvFXrQlQeMnoAl3QlrQlrSnRTFTrJUoSTDlLiLXSTFg6HT3STJgoMn4STrFTJTrSTrLZFl3ST4FnMXoSUrDlHUoScvHTvSnSfLkvMXo", + "AUoAcrMXoAZ8HboAg8AbOg6ATFgAg8AloMXoAl3AT8JTrAl8MX8MXoCT3SToJU8Cl8Db8MXoDT8HgrATrDboOT8MXoGTOTrATMnGT8LhrAZ8GnvFnGnQXHToGgvAcrHTvAXvLl3HbrAZoMXoHgBlFXLg3HgMnFXrSnHgrSb8JUoHn6HT8LgvITvATrJUoJUoLZrRnvJU8HT8Jb8JXvFX8QT8JXvLToJTrJYrQnGnQXJgrJnoATrJnoJU8ScvJnvMnvMXoLTCTLgrJXLTJlRTvQlLbRnJlQYvLbrMb8LnvLbvFn3RnoLdCVSTGZrLeSTvGXCnLg3MnoLn3MToLlrETvMT8SToAl3MbrDU6GTvMb8LX4LhrPlrLXGXCnSToLf8Rg3STrDb8LTrSTvLTHXMnSb3RYLnMnSgOg6ATFg", + "HUDlGnrQXrJTrHgLnrAcJYMb8DULc8LTvFgGnCk3Mg8JbAnLX4QYvFYHnMXrRUoJnGnvFnRlvFTJlQnoSTrBXHXrLYSUJgLfoMT8Se8DTrHbDb", + "AbDl8SToJU8An3RbAb8ST8DUSTrGnrAgoLbFU6Db8LTrMg8AaHT8Jb8ObDl8SToJU8Pb3RlvFYoJl" +] + +const codes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*" + +function getHangul(code: number): string { + if (code >= 40) { + code = code + 168 - 40; + } else if (code >= 19) { + code = code + 97 - 19; + } + + return toUtf8String(new Uint8Array([ 225, (code >> 6) + 132, (code & 0x3f) + 128])); +} + +let _wordlist: null | Array = null; + +function loadWords(): Array { + if (_wordlist != null) { return _wordlist; } + + const wordlist: Array = [ ]; + + data.forEach((data, length) => { + length += 4; + for (let i = 0; i < data.length; i += length) { + let word = ""; + for (let j = 0; j < length; j++) { + word += getHangul(codes.indexOf(data[i + j])); + } + wordlist.push(word) + } + }); + + wordlist.sort(); + + // Verify the computed list matches the official list + /* istanbul ignore if */ + const checksum = id(wordlist.join("\n") + "\n"); + /* c8 ignore start */ + if (checksum !== "0xf9eddeace9c5d3da9c93cf7d3cd38f6a13ed3affb933259ae865714e8a3ae71a") { + throw new Error("BIP39 Wordlist for ko (Korean) FAILED"); + } + /* c8 ignore stop */ + + _wordlist = wordlist; + + return wordlist; +} + + +class LangKo extends Wordlist { + constructor() { + super("ko"); + } + + getWord(index: number): string { + const words = loadWords(); + if (index < 0 || index >= words.length) { + logger.throwArgumentError(`invalid word index: ${ index }`, "index", index); + } + return words[index]; + } + + getWordIndex(word: string): number { + return loadWords().indexOf(word); + } +} + +export const langKo = new LangKo(); diff --git a/src.ts/wordlists/lang-pt.ts b/src.ts/wordlists/lang-pt.ts new file mode 100644 index 000000000..07807c96a --- /dev/null +++ b/src.ts/wordlists/lang-pt.ts @@ -0,0 +1,10 @@ +import { WordlistOwl } from "./wordlist-owl.js"; + +const words = "0arad!ototealirertainrasoent hoandoaR#riareha!aroele'oronul0Aca%AixoAl A%rDuz'El]Er$IsmoO$ Rum S-&T(i&TigoVo[=0F&.Il#P' S?S* So&/Sun$Tr&0Ac#Adu+Al/A[f E End(Er_EuIng'Ir?IvoOl{oRac Revi=RizU&Um0Di$rM-.R>o+TismoT|@Tu 0Ali An%Ar@Ent&Es,I?Is Ul,1Ila1Ar E=Ei%Ulejo:B BosaC&]uCh `C@GagemI+c>~/Se#S)n%Ta)Te=rTidaTomTuc Unil]3B(IjoIr^IsebolLd!eLezaLgaLisc Ndi$Ng&aNz(RimbauRl*d>_Sou_XigaZ(_3CoCu=En&Foc&Furc G|naLhe%Mest[Mo$rOlog@OmboOsf(aPol Rr-$Scoi$Sne$SpoSsex$TolaZ _2Ind#OcoOque 2A$BagemC#CejoChec]Ico.L^LetimL]LoMb{oNdeNecoNi)Rb~h>d>e&R+c]V*oXe?2AncoAsaAvezaEuIgaIl/Inc OaOchu+Onze O$Uxo2C]DismoF LeRacoScaS$Z*a:Bimb Rn{oRpe%R['>)zRv&/SacoScaSeb[S%loS~oT a)Tiv UleUs?U%l V&oV(na3BolaDil]G}]Lebr L~ Nou+N,N%ioRc Rr#R%'oRvejaTimV^2Aco)Al{aAm#Ap^ArmeAticeAveEfeEg^E'oEqueIco%If[In`oOc&/Ov(UmboU.Uva0CatrizCl}eD!eD['aEn%Gcui$Rurg@T 2A[zaE_Ic OneUbe2A=Ag'Ba@B($rBr C^El/Ent_E,Gum`oIb'IfaIo%L L{aLh(Lid'Lme@L}oLunaM<=Mb* M-.MitivaMov(MplexoMumNc]N=rNec.Nfu,Ng` Nhec(Njug Nsum'Nt+$Nvi%Op( P{oPi?PoQue%lRagemRdi&Rne)R}h>p|&R[ioR%joRuj>voSs-oS%laT}e%U_UveVilZ*]2A%+AvoEcheE=rEmeErEspoI^Im*&Io~oIseItic Os)UaUz{o2B+m SafioSbo.Sc<,S-/Sfi#Sgas%Sigu&SlizeSmam SovaSpesaS)queSvi T&h T-$rT} Tri$UsaV(Vi=Vot#Z-a3Ag+maAle$Da)Fu,Gi.Lat#Lu-%M*u'Nast@Nh{oOceseRe$Sc[)Sf ceSp oSque%Ssip S)n%T?UrnoV(,Vi,rV~g Z(5Br?L|i=M?M*#NativoNz`>m-%Rs&SagemUr#U$r2EnagemIbleOg @2El EndeE$PloQues><%Vi=,:1Lod'O Olog@0Ific It&Uc#1Ei$Etiv 3E.1Ab| Eg(Ei$rEncoEv?Im* Ogi 0B goBol#Br~/Buti=EndaErg'Is,rPat@P-/P*#Polg P[goPurr Ul?0CaixeC-#Ch-%C}t_Deus Doss Faix Fei%FimGaj#G-/Glob Gom#G+x Gu@Jo La.Qu<$Raiz Rol#Rug SaioSe^S*oSop#T<$Te#Tid!eT|.Tr^T~/V(g Vi#Volv(XameX($Xof[Xu$1Id(me0Uip 0E$Gui=Ra)VaVil]0Bopeu0Acu Ap| AsivoEntu&Id-%Olu'1Ag(oAl Am* A$Aus$Ces,Ci.Clam Ecu.EmploIb'Ig-%On( Pof>p>tu+T@T|V|i)X*aZ-da3Ch#Ijo^I+n%L*oM**oNdaNoR>i#RrugemRv(S%j T&Ud&3ApoB_seC Ch{oGur#L{aL/LmeLtr RmezaSg^Ssu+TaV`aX?Xo2AcidezAm*goAn`aEch^O+Utu Uxo2C&C*/Foc GoGue%IceLg#Lhe$Rj Rmig>noR%ScoSsa2Aga)AldaAngoAscoA%rnoE'aEn%E.IezaI,Itu+On]Ustr U%'a2G'L+faSodu$S$TaTil/Ve)Z`a3L#Le@LoM^M(Mi=N(o,NgivaNi&NomaN_Ologi>?Rm* S,S$r3Nas)Nc*o2Aci&IcoseOb&Orio,2ElaIabaLfeLpe Rdu+Rje)R_S$,T{aV(n 2AcejoAdu&Afi%Al]AmpoAn^Atui$Ave$AxaEgoElh EveIloIs&/I.@Os,O%scoUd#Unhi=U)2AcheA+niAx*imEr[ I Inc/Is#LaLo,Ru:Bi.Rm}@S%V(3C.eRd Res@Si.3A$B(n D+.EnaNoPismoPnosePo%ca5JeLofo%MemNes$Nr#Rm}&Sped 5M|#:Te2E@O,2N|#RejaUdimR_SmimToV&iZida3Jum9An*]Elh^G?I>n&Rr Vem5BaDeuDocaIzLg?L/R#Ris)RoS)::B edaB|&C[C)n%Dril/G )GoaJeMb(M-.M* MpejoNchePid P,R{>gu+S<]St_T(&Ti=VfimRgemR*/Rmi)Ro$RquiseR[coR%loRujoSco%Sm|+SsagemStig Tag&T(noT*&Tu.Xil 3D&]DidaDusaGaf}eIgaLc/Sc~ SeuSic&:Ci}&D?JaMo_R*>r#Sc(TivaTu[zaV&]Veg Vio3Bl*aB~o,GativaGoci Gri$Rvo,TaUr&VascaVo{o3N N/TidezV` 5B[zaI%IvaMe M*&Rdes%R% T Tici TurnoV`oVil/Vo5Bl#DezM(&Pci&Tr'Vem:0Cec#Edec(JetivoRig#Scu_S%t+T(Tur 0Id-%Io,Orr(Ulis)Up#2Eg<%EnsivaEr-daIc*aUsc#0Iva4Ar@Eo,H Iv{a0B_Ele%Is,It'0D~#E_,Tem1Ci}&Er?On-%OrtunoOs$1ArBi.DemD*&Fci&Rd&RedeRtidaSmoSs#S%lTam T-%T* T_noUl^Us 3C~i D& Dest[D@t+D+G^I$r&IxeLeLicplexoRsi<>%nceRucaSc#SquisaS,aTisc 3AdaC#Ed!eGm-$Last+Lh#Lo.M-)Nc`NguimN]No%N.On{oPocaQue%ResRue)Sc S$laTg-$Rje)Tur Ud!eXof}eZ}&3C C~ DaD-$Di#Do,Du$rGm-$G[=Gun=IvaLe$LvagemM<&M-%N?N/rNsu&Nt#P #Rei>*g>+RvoTemb_T|3GiloLhue)Lic}eMetr@Mpat@M~ N&Nc(oNg~ NopseN$ni>-eRiTu#5B(fis)Rp[s>[&Rt'Sp'oS%n$:B`aBle%Bu^C/G `aLh(LoLvezMdioRef>j>+xaTuagemUr*oXativoXis)3Atr&C(Ci=Cl#Dio,IaIm Lef}eLh#Mp(oN-%N,rN.Rm&RnoRr-oSeSou+St#ToXtu+Xugo3A+G`aJoloMbr MidezNgi=N%'oRagemT~ 5Al]C]L( LiceM^Mil/N`Ntu+Pe%R>ci=RneioRqueRr!>$S.UcaUp{aX*a2Ab&/Acej Adu$rAfeg Aje$AmaAnc ApoAs{oAt?Av E*oEm(Epid EvoIagemIboIcicloId-%Ilog@Ind!eIploItur Iunf&Oc Ombe)OvaUnfoUque2B~ CquesaT` T|i&:7V 3Bigo0HaId!eIf|me3Olog@SoTigaUbu0A=InaUfru':C*aDi G o,I=,LaL-%Lid!eLo[sN)gemQu{oRe)Rr(Sc~ Sil]S,u+Z Zio3A=D Ge.Ic~ L{oLhiceLu=Nce=rNdav&N( Nt[Rb&Rd!eRe?Rg}h>m`/RnizRs R%n%SpaSti=T|i&3Adu$AgemAj Atu+Br?D{aDr @ElaGaG-%Gi G| L ejoNcoNhe)NilOle)R!>tudeSi.S$Tr&V{oZ*/5A=rArG&L<%LeibolL)gemLumo,Nt!e5L$Vuz`a::D[zRope3QueRe.Rife3Ng ::Ng#Rp 3BuL?9Mb Olog@5Mbi="; +const checksum = "0x2219000926df7b50d8aa0a3d495826b988287df4657fbd100e6fe596c8f737ac"; + +export class LangPt extends WordlistOwl { + constructor() { super("pt", words, checksum); } +} + +export const langPt = new LangPt(); diff --git a/src.ts/wordlists/lang-zh.ts b/src.ts/wordlists/lang-zh.ts new file mode 100644 index 000000000..67b94a82b --- /dev/null +++ b/src.ts/wordlists/lang-zh.ts @@ -0,0 +1,83 @@ +import { id } from "../hash/index.js"; +import { toUtf8String, logger } from "../utils/index.js"; + +import { Wordlist } from "./wordlist.js"; + + +const data = "}aE#4A=Yv&co#4N#6G=cJ&SM#66|/Z#4t&kn~46#4K~4q%b9=IR#7l,mB#7W_X2*dl}Uo~7s}Uf&Iw#9c&cw~6O&H6&wx&IG%v5=IQ~8a&Pv#47$PR&50%Ko&QM&3l#5f,D9#4L|/H&tQ;v0~6n]nN> = { + zh_cn: null, + zh_tw: null +} + +const Checks: Record = { + zh_cn: "0x17bcc4d8547e5a7135e365d1ab443aaae95e76d8230c2782c67305d4f21497a1", + zh_tw: "0x51e720e90c7b87bec1d70eb6e74a21a449bd3ec9c020b01d3a40ed991b60ce5d" +} + +const codes = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +const style = "~!@#$%^&*_-=[]{}|;:,.()<>?" + +function loadWords(locale: string): Array { + if (_wordlist[locale] != null) { return _wordlist[locale] as Array; } + + const wordlist = []; + + let deltaOffset = 0; + for (let i = 0; i < 2048; i++) { + const s = style.indexOf(data[i * 3]); + const bytes = [ + 228 + (s >> 2), + 128 + codes.indexOf(data[i * 3 + 1]), + 128 + codes.indexOf(data[i * 3 + 2]), + ]; + + if (locale === "zh_tw") { + const common = s % 4; + for (let i = common; i < 3; i++) { + bytes[i] = codes.indexOf(deltaData[deltaOffset++]) + ((i == 0) ? 228: 128); + } + } + + wordlist.push(toUtf8String(new Uint8Array(bytes))); + } + + // Verify the computed list matches the official list + const checksum = id(wordlist.join("\n") + "\n"); + /* c8 ignore start */ + if (checksum !== Checks[locale]) { + throw new Error(`BIP39 Wordlist for ${ locale } (Chinese) FAILED`); + } + /* c8 ignore stop */ + + _wordlist[locale] = wordlist; + + return wordlist; +} + +class LangZh extends Wordlist { + constructor(country: string) { super("zh_" + country); } + + getWord(index: number): string { + const words = loadWords(this.locale); + if (index < 0 || index >= words.length) { + logger.throwArgumentError(`invalid word index: ${ index }`, "index", index); + } + return words[index]; + } + + getWordIndex(word: string): number { + return loadWords(this.locale).indexOf(word); + } + + split(mnemonic: string): Array { + mnemonic = mnemonic.replace(/(?:\u3000| )+/g, ""); + return mnemonic.split(""); + } +} + +export const langZhCn = new LangZh("cn"); +export const langZhTw = new LangZh("tw"); diff --git a/src.ts/wordlists/wordlist-owl.ts b/src.ts/wordlists/wordlist-owl.ts new file mode 100644 index 000000000..5b8d7c0bd --- /dev/null +++ b/src.ts/wordlists/wordlist-owl.ts @@ -0,0 +1,57 @@ + +// Use the encode-latin.js script to create the necessary +// data files to be consumed by this class + +import { id } from "../hash/id.js"; +import { logger } from "../utils/logger.js"; + +import { decodeOwl } from "./decode-owl.js"; +import { Wordlist } from "./wordlist.js"; + +export class WordlistOwl extends Wordlist { + #data: string; + #checksum: string; + + constructor(locale: string, data: string, checksum: string) { + super(locale); + this.#data = data; + this.#checksum = checksum; + this.#words = null; + } + + get _data(): string { return this.#data; } + + _decodeWords(): Array { + return decodeOwl(this.#data); + } + + #words: null | Array; + #loadWords(): Array { + if (this.#words == null) { + const words = this._decodeWords(); + + // Verify the computed list matches the official list + const checksum = id(words.join("\n") + "\n"); + /* c8 ignore start */ + if (checksum !== this.#checksum) { + throw new Error(`BIP39 Wordlist for ${ this.locale } FAILED`); + } + /* c8 ignore stop */ + + this.#words = words; + } + return this.#words; + } + + getWord(index: number): string { + const words = this.#loadWords(); + if (index < 0 || index >= words.length) { + logger.throwArgumentError(`invalid word index: ${ index }`, "index", index); + } + return words[index]; + } + + getWordIndex(word: string): number { + return this.#loadWords().indexOf(word); + } +} diff --git a/src.ts/wordlists/wordlist-owla.ts b/src.ts/wordlists/wordlist-owla.ts new file mode 100644 index 000000000..750905bc4 --- /dev/null +++ b/src.ts/wordlists/wordlist-owla.ts @@ -0,0 +1,18 @@ + +import { WordlistOwl } from "./wordlist-owl.js"; +import { decodeOwlA } from "./decode-owla.js"; + +export class WordlistOwlA extends WordlistOwl { + #accent: string; + + constructor(locale: string, data: string, accent: string, checksum: string) { + super(locale, data, checksum); + this.#accent = accent; + } + + get _accent(): string { return this.#accent; } + + _decodeWords(): Array { + return decodeOwlA(this._data, this._accent); + } +} diff --git a/src.ts/wordlists/wordlist.ts b/src.ts/wordlists/wordlist.ts new file mode 100644 index 000000000..d6e6c0178 --- /dev/null +++ b/src.ts/wordlists/wordlist.ts @@ -0,0 +1,22 @@ +import { defineProperties } from "../utils/index.js"; + +export abstract class Wordlist { + locale!: string; + + constructor(locale: string) { + defineProperties(this, { locale }); + } + + // Subclasses may override this + split(mnemonic: string): Array { + return mnemonic.toLowerCase().split(/ +/g) + } + + // Subclasses may override this + join(words: Array): string { + return words.join(" "); + } + + abstract getWord(index: number): string; + abstract getWordIndex(word: string): number; +} diff --git a/src.ts/wordlists/wordlists-browser.ts b/src.ts/wordlists/wordlists-browser.ts new file mode 100644 index 000000000..fe2bd4e90 --- /dev/null +++ b/src.ts/wordlists/wordlists-browser.ts @@ -0,0 +1,10 @@ + +// wordlists/wordlists-browser.js + +import { langEn as en } from "./lang-en.js"; + +import type { Wordlist } from "./wordlist.js"; + +export const wordlists: Record = Object.freeze({ + en +}); diff --git a/src.ts/wordlists/wordlists-extra.ts b/src.ts/wordlists/wordlists-extra.ts new file mode 100644 index 000000000..21226ea08 --- /dev/null +++ b/src.ts/wordlists/wordlists-extra.ts @@ -0,0 +1,15 @@ + +import { langCz as cz } from "./lang-cz.js"; +import { langEs as es } from "./lang-es.js"; +import { langFr as fr } from "./lang-fr.js"; +import { langJa as ja } from "./lang-ja.js"; +import { langKo as ko } from "./lang-ko.js"; +import { langIt as it } from "./lang-it.js"; +import { langPt as pt } from "./lang-pt.js"; +import { langZhCn as zh_cn, langZhTw as zh_tw } from "./lang-zh.js"; + +import type { Wordlist } from "./wordlist.js"; + +export const wordlists: Record = Object.freeze({ + cz, es, fr, ja, ko, it, pt, zh_cn, zh_tw +}); diff --git a/src.ts/wordlists/wordlists.ts b/src.ts/wordlists/wordlists.ts new file mode 100644 index 000000000..459f93721 --- /dev/null +++ b/src.ts/wordlists/wordlists.ts @@ -0,0 +1,15 @@ +import { langCz as cz } from "./lang-cz.js"; +import { langEn as en } from "./lang-en.js"; +import { langEs as es } from "./lang-es.js"; +import { langFr as fr } from "./lang-fr.js"; +import { langJa as ja } from "./lang-ja.js"; +import { langKo as ko } from "./lang-ko.js"; +import { langIt as it } from "./lang-it.js"; +import { langPt as pt } from "./lang-pt.js"; +import { langZhCn as zh_cn, langZhTw as zh_tw } from "./lang-zh.js"; + +import type { Wordlist } from "./wordlist.js"; + +export const wordlists: Record = Object.freeze({ + cz, en, es, fr, ja, ko, it, pt, zh_cn, zh_tw +}); diff --git a/testcases/README.md b/testcases/README.md new file mode 100644 index 000000000..cd049d253 --- /dev/null +++ b/testcases/README.md @@ -0,0 +1,4 @@ +Testcases +========= + +Please see the [testcase generation repo](https://github.com/ethers-io/testcase-generation-scripts). diff --git a/testcases/abi.json.gz b/testcases/abi.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..ece572ae623d347bf29d7f83caca4df614ef1af4 GIT binary patch literal 1118569 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

rAb(_UpsicahC(%)SCa?AUe>&&Wwk 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 Q=sLm2?D^O}XIU?f59NyA3_wuSAjRVU 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 ~G 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 z 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%0AP)>9&tjCq@J3-y@9`Bz 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%0DW53=t)Tw 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⩔pfg3 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 UI}lE2&B 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 !XCjxb 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¡^I(>aQ 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 X&&Txc#o_CV4=?^774bnwT+(a+NJMXK literal 0 HcmV?d00001 diff --git a/testcases/accounts.json.gz b/testcases/accounts.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..867fc98a3d4fb1a7d477837b8345bede958f501a GIT binary patch literal 26153 zcmV)rK$*WEiwFP!000006STd_&TPAKCN|eoTxeVZ*f*Z7j@kEpdc@WiP?8FgVAy5& z-TlSBR=Iq0We#k356;>9Zx2C)1Z~qkk^MC$-KQ!~>b2CHhnChHS!pdrGKbbaZ#=21i9lB8pHhOMcpUmG5 z&HB|zaP?X(j!X8qZ{8c@{4iekld{)4Gq<^+{p&yePyh43|HFT+|N1ZgkpA)C|9_Z1 zK0C&crBF;5W4RNB^IrHClg_$IA**A`VesxhzV-heBh%N#x_dokFQ)CJ&ZAl{4)=b! zJ+aICdD^+zF~)x`|ME}&z~)EiO5zT`muHrX^sThSl$92bRz+^fR4gj4nZdiQtr_Wk ztK4f@tI1r=El%#dkKQ>9k?AsqCXI;3d#AKFYGlqEnFbyIc67>$`$FIM*ZXqIR_r2o z?`g%(YcD!1qRmNC~h|XfT(L`RW&{^QwjPbfD<5VtI$L1|& z#Mh#7YjdHeRg)N9l%jW1j(o_|grL*L`s@W}+$!h!N9ZX%9(#SVqmo+p>&NCf-JU(a zFm>QoZy({u=){+~%Pkuwoe?aXoLx#rmLij}s${Gv>7!~%VoGCaMJZmitIS9A(Yd6! zWF5<$^_C?UT_=;9vWvngtTC^A@jiSYr?U&c9rxjMxEryem#{N(|Jc6#p$p1&(~r^V z`OzhyN)wi*j&TAx)qn*?a-)StxH*i?aV4}*mF1*;1G;eFg5lYFmgnM*b1q7;L2!$e z?%bew7rYa0vWZEllava`^|zz*YP5@|c%PPQH=d^ZsNQQX*W3GZby%&RkN1z!nfcLG zZ*}pCNmi=Qg-ZvxEC3eSBmhSyWi=vFaG{dZ&H1Jfi3}4hjYOo*txT!<;s@(x5ajtp^G*#2zj*h#2yD_hz7iQ_%`f-U`wWd$s#9Iy*nQ#)Ob~ znU%Q$7_U*v%u0&DLx;EQDl@)`*t8LzTdQ()1vJO7M1`)^&y22#ZfJfe!{m&cM6A;F zM%&Jq7?e~ZDS)sLpPbGv!-~1kZ?0#(G=5r#MZY-lj=z`3>+3Yn>3M|$0oF=sX4+#A-MO`+BibFgBk$xU5SY7h|sG8jvg+9^Bs+%vqx z&I%qrh9}s>2E9|8=lZcY?+~Nm+{xj%7>~nvIW4ZghWACSB#!7efK8cl&M{U@62sp` zwm=o>M6(P6L)8jF!x#cnRzgz+30Hx!b9@fL2Cdd(^%krME3{In8_m$!G9j#$8fDT^ ze9WFxi_^}or{#ImErj2#%=;9Ce)Qdjb(`@QC-84_r7D?XQ(QDrtpNK0IY3TU%2p(E z2}@H$do`IX=BrezI0PxHzNUn=J2O1I6WELDD%aN4$$~;+>a82H1-bBqNd;C z@5gTW+IzXzgSpFb)a#3MuS2&!n(p{(cwYodR0NhTLp)+22|O3QWDU+!S_wTV9oR6b zMjE?9Ke|SvU`p5PGE~_j&vxv1h=cJ;4{n-9#e3;KU91+zjdFdE z>+5PSP4~iz-uQ5Huj}G%hhM|{qF5L)wTH0qS<4LNRkOniZ8wA-D=}fQ<#PV zPs*V`U5Xh-Alf;#DLg}f$;@qY9sE?U73*Wv7D&UI&>~^wC#ybq!Kq6a-F~&)?KYc< z@%Pj1*1LzeGJQ8}%YF^-i(~<-vBZ_eV)4w!40OyCX*ya>!i9ke;E!r_e}Gfi6lrC# z6yc7b1ZIXe70@@Z*SisDf_Im@!G+8Q6+jDBIk*tv_=nAN_I&CwOWV^zig7tk08M=p zVtect)Ai&|zlQfkvp_Yoszm{8C96T$2{<5qf{uaZ;TAIi(P0{31WLFDwgo5z;Kh)fRhn#W{z3Gk8`fzxxF`jj&U#HW(7w@px zFSoyj_eHfZU}f@EsAwBtO*5Ze@t{B#TZDEgDk9{)aiy}ToGLJD2?Ua%$8xfBE`6F} zZ$bg5NEc0J!NSjX+$7GbG0H#`bS8QGft=!e->;8LA6ESAFZ<~+Ue+6NA1@cXGB>{d z<k~GXHAd6DkR}CZp8Gx;vv00QF;d&z`!vSTTnBzUIW#{@X zVcMg!w!*qr1-%I)Dalf)2$>+lhmpl+U(jA9Y*iJu|E599X>$`jW8r~Px z!XY#{h)A~xPnQco#DKf8I029dF(tjwr3j-`RI-Q+peB!`D=JzR12`* zGH-z`jJH%_>+o)&K^cYx4g}ljYI4=!bLPPM8lfkZ0Hp6*_C6|ShQp?s#3&6oY1OU~SIms!x@8K{)$Hz`|t_1vK<3z8? zJ#YoR&g>+4`J6m`*&fEzE?hUS=l*nhE~k}RJ{+u3FzTnG7GFdQXD(X!F}T&_oQ1## z(=}tVQzAoW!UDNOyA&1v3{;IjAb)}QF%XrrUUst1_g)L-yRPGycqXk)J^VczfzN{% zqD+Xr4^~%azJE-|hj`n~VXrrSE7tevcw9c8&wV)De+}=8XvtDTTt)cOq;zzuNeoEl z0^3>`bQ!3xC9e|HC3Lm+m`ewj+YF{o>)9=`u8SeEIC{as)W!ht6CC<5a;=8~$3OWL zT>Rh#qu0;#;VDP8dwcO(v+L3=&UV@JeXqCHJbw-Ei)hgdZ#ES?YQ>{qKuJWXXT0(3 zY68$y-w;Wltm5$o64s;@!dl^Csl1B0#c7#=?eDAs$r*)7*9|Mr44Rn<_K%O*dDne} z9@cG`hW>oULcZ@eugk;UnK^+WUVJ~u!%t-SB3fd$rKOZ~El`<-F)y|BkYx-u20_QL zAO$`QgU||s)bJvGkw&*a_F`^v>JUaQlq$}220s93*{TUl8KZmJq!qg3SQsC}W4+xk zSh#67?z`@Chx-EXId|k3F28 zVe{l0_nJ=6JzGBxPVOfCYjj^U3mzPHRwY#!WEVt;NxCF%Bpo$)o50FkSi^NrGQt8t zSZi%lY?I2|3))=)oFrwk zf%1rOQ1BCT!0GZ(EoVT&Mj>Xi?mcF*X{#_!P`w8zi1W-Va0sO8aBmC&>Gx9BAv$I&otsJx5ktJi%X|rEedU(!_->t zGT3sC_OQaOoM4$e7JwUau7P_?=U_f@U!9&zQKJ9Y!8Lrf-#w3uot}g}T)Opc`Q8c` zqKSbi4$EJ5NPf{QjdoZgX)jD)^I$8m0GHZgc$Uud1h5h)S|CWFJY@mf84JPRTuzXt zbF&AcbU8pX3)wmZ8)+Np0;e?#5%MEzGcotEPsZJ8ap2o-??$nFFNbk)Qq!AX4v&?( zZ0~peYj|HoOT*}NgVp0;GL?KZu7Q zG$sR17ZYu1TgEZKG8$(>r{S9iJw)&0=cyidi^J(8`8J&T_0p?XAMAZPo&D9WkEi41 z7pu!JqNQ;Wi>@NUp5mp$`aq3nsBA(QUjZ#XMF1W=Zw=4Ce6iO>nD79a%nKa zHDRN+8Z?No9x?wwD>nA5W1l-M>>9@9{&7By<|M*#`{e6ec<(y-e9_6*uX8>5MYK40 zoJ>cu-euZsh{<~wE9lK9>zJjJuSPqc476pmbtd~#8{;{8nA<^%$b*MKYxVE$|ASCE_?( zfaHpBndC`StyyCCq~HY!8+?SGiL|R`Az>0!j`DC!Gs9D9$_x&e2OY+dcT#i9YJ|oc zL@x&E93Qk~-3PR2clX=Z$Srj6{=8aCqmGZ|&B@6>`F{WF@JoJEEd?tNFd>|)k}(WM zC!nRqN1A95qLxQ54K!Gy(>*$&Zc^Z@vxdG_bCOf(P}qQFL0h#A62Umtjg)dRDGUEU zsnO^DllQ=^rXPh|J)h&FTfg7x5hi^fnQ>P>F7B^iXX@Wn3*<4P2%6ck=xA>Q2yP%y zVCh<6ScN9F+^`P4svb7AkEF-4OKn zft-#l_Bw3d_w5#6ca)p!)nj6Zs;bvLqw|U`TF?9d+Lj7k*dT7M_qM>M>UpPrL_ft!xTVN0nMv+9s*f8 zIQRz40Ucm)ML=-RZv*zuD_6kJ%7Y{^Yd}&1I)%PwO^jfRfydZ?9Df}sZFt>1dQDh-AIKhA> zxTn+><71>FvN=gDv(C&7}3Uom#v)H66#N z*`4IRJ3QV~C*Jpd>wgXJi)x`P%cdyBp^%=;cCNJ(Iwkf8 zJO1)R>f25W2BNErhR(GhR*WiDn<|y&)imG@XdNP#Q{EmuC&Xi{9vt}R>}&SylE@@_ z%#ZI)<}Mh=Iyod&5s7V>#+I~%Cz>(qTrRG6Hio`C-re~w5Bu}}rd2>F`}5)F7qQ`8;lSDo+^0&xnI zS%g7spmpw@7lRJ9Po4TS>t^+wM%%qMFKz6OGrzu$0mOa&#nWwz2Bcq*qz41VeQmvtr_C+@w~g&ui4XIM2oKgdq^zcq@lB}q(NrZ zQuG5$p{1*0&geuysWQOSaEz}K-WC_*Y>IfIZ<&%%z37$oT6adJaWHgp4HwTxHMTZ= z?opc!)8qcIdxH-a`nlh4wqp-FblN`jVK0AaGW|ug@M4mX+`x+`;5Ym$0#7;+8lb>A zQ-y*%)5*gsdkuSI^7oyxdzcUiO#uwR^rrP%Eu|9nI=5qJ=VtIVe|>3KQTw&^dw(+9_p&g=uXo z(KL7iEefxk)6C!@7{fpjWi!JYAPMvUGc&Y-dp~-ey&2(ytH#grtdC4YYd(0v*}YnB z!a?eB>Ks2UrPSfNIQDPJE^c%EMGX4e`B19a)z*}0USQI)NtyC8@aUeP##vR#wVJs&dDC_CCW3^h)?PrXWzcrIoJz1;lNaX$6(^JrF|-g3BvXUB%Y z?~m5={`tN?hU0B|T*X=a8s4|_p{PVD4)BtiZ;eu@F<)RVfTbWoB`v44aD=BQR>EG` z3g3`R6L3;>PI4+1;68+6lnw-nK#X!_J03io7oF}oho#beEKcX_R!#`H!)tup_3<&9 z-TLX|xY}OD;cR{>YW+pDz!HF4xPd0bno&gUaN;JyCrM0?lG#hyn4ujP_)^Iss%2_I zDm=B9 z>qhsoZ=lRfr`Tfj$^(R=3Zw0dqU2mP_Qrmy7SZ1i)6u$1uXf>ac|ZU#yISlPy=NOP zewlUsMYS;9@Z8bi0UMnPnZzN}GISRMWSUF|(UfqUm^W>yHMDY!5A9KZ*_Ronc<~BZhn|L z*_jES!Albf<^j4Iz-de$OJA+|5M@qmj*GXwbZ>|6Kh_1ROVq$Ms|mZ)To;+SxV#Qu+0N4eyI; zfw;^DYmwvCQqC9{n09KjRMO|B;Iwn*j3^L-UI^IS3aN&9tWdtW9H9* zH0wAUr&03`bZ_trOb=E5VfP@Dj@`vOvwg@t-@kXxV9a43wwv{Fc?#y&@V=-PI(mfx zD7j!!YK8&XCM)m~TG|S5Jai_N-$X}8vRK9}0Xp%O60pN&(*eC5_>`u=z~F*=43Cl= zt?!%xe5DNi5KQ%-IsRgKGJ1JBUiHD6_iE3UyTP8VysyLUd0PL9J@ZAiIH^GFcs%WL zB0f(U7@4^CRdQ{!#UKExcm)}ZoH@tz6;2)sfdor5JA1Cf>!5T=pHx>6++L~<2Dgj} z6W5b!we~aZ!|Q{xkC!TB1XrNFJ{!NKDBq z^fevv(e5pyECH(QGcd848R#lbSrQO08ALdzIVl|w?9gkdH`Z#)h4Mdr@PY}^86yTp zCyJlDxZ`s>9xmo0pLf378|!W&nB#LZK1N8FUsY}9TPiNRSQeG%`lkvKgQS8Aotvig zTzGg&Q*0*Ns7f-xJwi;aXn(L;%jb^w8vJ?J6^T~>MFjFUS`3pl0<7B6ew3Pu7N4}P z?DfX?KJ=H<%dA#6^H}pE=N(+`J`7^{E33tPOU0$VStu81Q7t-SdRPKbnv$LJ0{E=~An<89`Xmj4On?z# zoT`bKG9$ciQmaDSeeCGN)1UpQT@4R0{|lCIL>5^DLd!0+isGD+1Cb8rrrsR_0hSGE?b{ z4$8E74Lgfy!dK62C555u!JMj}dOO%M70RQ8anuG*%Z><5HSqL74BYYCbU2#Z<<7!r zm_J``<6RD1ZfTR3`sIzjBRkVM2L#> z*fO_t1UNIinpvKxf{oWvVbZjM=VM?_VRY9(r>w|uSrum$h= z@x5FBtlayy*AfNultN7j)DpUjb^=X{s?wGV*d5efqAlJ|HWlW2gma67kbDWM&uwFf;Q3{Z_ttD&9+|dlWR#Sc%v1SACTI zc0iP&etq@8O9)IWVEzF3#d^xh^+mMYM6HcLADwZ~~Odg%`B|MFqp>?MK!Qj38$>dp<4J*Q4C{QJP_MQH%BRetkUd$6qHX_M2+a zPGc#0s1oRt1n_|2@jNP9J*5x8A^=q?!l*#LM4n2d%}_5q`%}3-H@ty+iy5w>iQe{p z)GZ505)qSW2_V6As9JpTo}ZR?aoTiNjIXP@Zmt`Dxyfl^Zj5aZn!kqkMYU)~iI4Lyl`prP%Rw&t>ui^g{}|pE)uMQGO%{mF z0*M#}Vg>B$AyljqkSvm{gpL(}4ovaU7=@LaGh_{eNSi}W>nm4^C0KG7CRz*Lb%2vV zX(NzAdI&D4>5~}r+o+5T?k`hDbZ8#(fqs zaDFiMJ+3y88oJ-SPG=qX_&T%hu-G2$&rE9jMYR~J9R+9uVPuBiy+Ir(* z@1$u}mr9{X|862$Z=C}Twz=2?EgCwHpi+LTv+O4}4yp?lLXQEWTLSnn^LfS~{7oJC zW-?u;kBi_A=lyFHE)Thpr}6yrjKO_VEv`kz=`1TtQ=>!383V`DsIFUMoRDX zs)DHt<8*jHh-;ml+l&~zn%L0A3DMgFFu`;U!wnihJ5p&Iba^!SBj-wp{c80-U%k1l zmk)k7)5gJVU-UlgPs8H*>x9UCQ7uYRT8E(xA819|N7llVU!}zew+BY3K2n4lTP3Bv z@scV7+H&Qaoy|4o9hUT{BOH+j^BF1{5OVNPMIgOS4U=GCi;v9+dm8SSGgG_GEoj>v z?)&b!I`iALQ||J(|H^}RUsMYv!uhO=WDs6SJEN$)%M?Y4;I0sqizt$B$usy_=p%?- zp@b!jsdIh}8z0UxGgrS#eq@{vOXnf*429K0QYq>&? zrZR_|JXt)c4rA>cNK2*wNhccDMs>VrqtmSg7QyYC5d-!YEgphVYMg6B*8FZgH|n z!ScEQX8_9)D0jNDt`UR|Y3MoqbeQ(fybsRzuPYn35li$YXosQ%A{QCOpTQA+<&)vfK}G*C8@?Dze#e;pr8o-WdC#NCU_{o8%xdGy7)@ZldDDP+cKc%Fp6HTyi^-!i% zebf{)sb|%9FdioNw6Rk^H{rMU<8agVqQvxAOIXdM7#;R#{%C8fev$>PKS zN*!cFQ2kVUDl{!0+qlwi{rj}P^3DD6f-tx}FCL=$__*Huu-M68+qmwFYM}%U_%>NU zxmcE3M{Nu<&Ouu{Mn{+0RjVDArNuhdp0?3Jlu#ZLwrw`&N)L)>-%V~9RhTlhC2Dl4 zt2=?oG@Z&*m)++Pit5<@{=V(Z)-!v1?=Cw(9`{SOzMO9^JkGy{_eHfN&=&_CfE37+ zL5?NLZ2|dtQlJ@tLzVjYs;H@ui&4F4qk2PLfjzT{@GW*+iH^40g909tVTLD?wUd9g zsyd}xaG!bp`g&LWWq)`*_N(#aE~6Vq=n2)GPx>Nnza+K)rdp`>kkckS0?ac*70Hr` znqV9}rD93V;dn7$5uV$*W^JMpQ5f%HoS);p1dq@tseS;PL-85Mn;_u_=K>9d@tbCKl#b*|YzmT3Uk{@GQlaYAGHj2FfBjTcEXN zwv-Q8Z1U8_MNzFY?RFv@4Mq&gsB={s0g6OWbFazp8i1bgMo@afc&Krv^8ghK|1qM8JA&@E2%s2RAEtrFo_&g!fHiYrA zS~}}r$7vF)^V6IrcJkrAxva(M*ItYNme;~q{8NLdst`OI1#uxTMo*RqjG$ox1(dWS zrRh^*rP0ZH#UsK6`ne+%Dj6Y4@Es{x8KM7SUp_1Lok?&xEeTCnx<{<`nI zI;;o#K2FcW(u7_N*RWQ@>GVrd`!A|R5|a@s8V6*=Of@`$Z^pp?;AJ-n--EFhO^5A( z1giE^u(Oy$X_=qhjNn0b5)$sO-Lt%?Js)5@Vsu_&-3Bw|GPsZ7S+{!f(1q3Y9`^T< zh1;!Pu3rRvYS`b;zYd@Mx4af`9*|8(r4bka3u?v^sXe9Fyh*Det>FSQhFchQQSb!< z#%Fk6>Z3H5QzphNrB;n+RQTyiX zygRwg^gganzjn&}7u8Z=@?gY3WLTY4z}FuUV*8g?rgMy{j(JdmmwatgQcLh zjxEl%`;d7uOyocN`7{hl0damJwK)KXB{Uy%jC~wmf^1;V)N}uq_vPuazCpnB>@Dm? zvdgpE{n|?MUsQ{uVp&KRO$)MAS+xXJ(Fp>zBS}=&5IwNdROJ#cqC#m_hv{{+)l}y+ zXOu>`80`VYKPfm`z%~Fom9w)6kC@-l zU_A`@X;By|A%Z4S2{_gDvbsPmWIqeQm|XXLSUon2wdzlg=gB}c-PS|zhR2!r@|R=q z-&Bj07+p3QmX&&tVI7vlt+k97XldsnZTrv;9z=9fp#IFMrAwhBK|b50tXj~VBOtER zfVH4FTn7m?Ho_a5HnKV}(SO9AV`siO`=?O1PP5x~P^;&?-#zvZx44aXpr0+~zQ`7! zCU4XlfKgOopiJq~oCcT_*itwjXlg5>tg!ALBBs_Bb1YP;4-%Q%=uDk97!D$jb68<+ zIZT(gV@N>3o-x-2u7aA8E!*=}Zuzh~+422)GqqZ5!l0DxcAI{C``HMJebFscgD-P* z)QTf#%3Z+&v;;lLX;`!gs;RWzLNr2*#wHU&RVyZ#te(wgmDvIA)o=!QGSFkm^*I}x zM^7n1+(!;_sh_6|LJn%ZJgcoZzs*f9!eQ+Dbq9jzc7EFTzvu5;zZR7;AVWD5t;GW5 z31CvQro=zcR&2FZs!*>HFcO2sd|o;fYnXsV9~_^ z_Idbl4a}e3(@|gckE08Id01|z%l)?4LTH<5HU8Y|7$N_t5bOM_2Ibbw#VCT^**gGPk98g-{0~o{LfZi?AwluqpGK(SQ8l>uVEeJp9)}2 z?b0Bj4ec$pO7+5EL&}CJevxBcSC1LXDKd-Irn$KSUC=vFMXy_4GhIi%IeCF=O-YZQPOP3__c zC=rLWa~2B~N&#TVQM5Xnoit#UoL3M&O5%rWJ%N2Z7h^O~C^80FC&A@s$0U33=QG=% zJGSH7#pNXq-RivH=4r(JeBAu(LCU`MnyXc$%$xv>%Ltl}SbCO>yO)ftdUFj5%jouJ zCk<|}Q1ca+ORm%wYi4}lNxT3XBz$6@`{*e13h~XP^sX=5ButexABPRh>~8DOpYEHD zc4xh2hV2gObmGHxf8hH3tEo8f_zOQE((raA!oomOH|LSj(h zMqit%h|&4e6j6g`T^*YjlOCWH8pndQcEoy+)M{0mtR4GwwpuUOQmszoqU+Yq-1T(1 z8aBx1RxSIt{k3VvzctCNKDuh)#&T{Ie}O)U3N#Flpp{lsg96Ur#%jqTe0>Fpr5L?e zIc6j0#@9R|4JxObM(y+f`Nw_7sfQ2K1KA=kJ@n#dj*GsU!`64YKW*8tyzj$#n1*M6 zIXw4#F)V)d72@BziyoZl^W``eYS3eom*9Ut2_>mToM)`xz( zR6qO3e(RGQ!8K#_im(6v-78g zo8;IWJY>&72$QdV>O!pmP?j}5Iu3mLoIkM)?tXe1y6@9 zhFbNsGEUUc65kpGi=*l_IMt7zeSpREUORq+GGdRVdD_+by;*Jj`C<;w-RieL`qn8I zk_0?MjYvF}PqFZ_n7Ej00vkYPwj!cn)CAGx#^L&?K@=hpDjCYv&27FE86=P=m`c4O zeBqS+Pp63)zsvJLy?X{FK2OB-;oR-{>b)NB;c$Q7p2zD}T)>D2)xTH!-|O>>exZXn zgXyvqTH;S?b!4& zftj%OkkQVcE-PfH&zadzXHv7sAG5PSqRz&FTd*yyGNl&;iK zmHj6>(^>x2puri)poFX+O>f;lVKrSA;SEtl-^XOrtukzLR@8=`@?t%ZU$G@16bo!gFvfFVq1XrNG|a{UqWxq3 zlw9;;{qpjB-apq{K5oM4eP)aEaiv#_*XHN;%eQv9mR1>NjES z`F6L1dTqUW-9=QGt3TF&d+Lz2nD_|Y0&ul0IWUk7*H|!H%41e^G!)bRm z!!S7U=p;K&FTIxjq|a;iD^rkvYnfXpC%)o0{;5&1kZ6=-fXUI`dSyy2p0Zit={fWk zM8CH(VqvO3`A2aUUqGpjcRB!0I_Wwm!k>FKpx}k?6kN2JsJq=~Mu_Q;hb`}4e!mex z9p3IP_Q##P(q#eb{x`mSt1ha4tuCdzqdc$F5>>)B(7hN&Marei5_}cuz?~N!vF7kb zxc64W;Leu5RmK$JO#nzdaLwRbog0;{;g>)tD-<_Mgs}lU~MHe9j2wYQR+UBdF-KFhe4Uop1|Jjy;~i;yzA}dvAM`+xGk>_ z76!L9dw2h7|Gst21)xRh6Nq70Dm$qrvgC>bnJ1m0u4HYHXhLU>;Lp z7GEZO7G49N99&>np+ZojjM!z?GcBs_AY>W;IQw(rtd~KkKCIqdcYL~jIBquMbU(Z< zn=bUf@#R}tbi^7mJR=U7p)z4g^rV`02^#5f%rxRiy4OciPjxJ07%JLqn%h1L z4C1ueper3jm<}G2F1CQglT)GWD6XnAAMt0z!L09#<8jyPasQsK>)QdddU&z@VZRvE zPkr{SaW444co+se-)PWHYUB&y&G!I9*GJXb49Cx z%B&=Fg-cj=ybk;tKlDR@7x6RrB6V2#^YVCl^vmsqJxga7|JFJ; zmRw!pSaEcN8;c+aFSPK0IxQ^7E>}8{XOP$y{}UXt8^}_$N96K6w>>C%&j!4;4mw7_ z0Rs0SH^JS5H-DOqOK4j2+0O;8;__PU#>GmhEtJd>ZeG9M@*&UWE%&#d$1C4@=T>_B z*f2D@DgtJn^5qRzu2Kt-2JfVxi7}ZGKtusaSxrS~mb1v*%^g34fM^)4B2+3IT7b4* z9GBEYp1St+Zo*>!Oj~01dfBtx;&6C!u^ZOok-h!E7mvexb@H3>SN$UY);t$d!&L2+ z#wvA;s`y~FRRRLw4P&LsA`*g#Q#Eu3s?ye8HJL;zhm@SNx1;j|EdcAC8kwN$XtnG; zH(UqVafn<&O~O8oH=R3n_xJg&Pi(Pbdbsf2{RLur-%hXV`}q5K^IP{^%uB>_1B)B1 z)Jk`vB)S_?SGuW&D&9d9h&%;&(L&e=^FT?v5gwL9WY6*YP`xO^!pfR%U_QWSsD|YU z(c}IY4^DR%knuwA_xjpZxxle`?N*x287AWA_`cn)NG$^;m8%N|p2)3Q z8#Q5Fri;O{LzD>yjRx~XJ;1cKg0kiTE?|;4cYK5Zrfjt+JMa2Y+T=pQlGSXeLQmR{ zp?BG+&-!6uR-5Pce3QNF*QaoGFKD)~mCM)Z?3eFf8Oi)>16}w6O?NMGE|RviI`Kfv z7sIIi2Q4J#L5SXBeobzIDVel%w2EtWbN&{urjs5brgPMYLQu=qi5CI4ETWK5XTJI1 zKaP(KVDT4s! z?PNQBTi%zG8~UpdVZ5F;r-ys2_5J5nQ{Q^%7Qk849#m&op_4JX55?w&_g+|0%po*k z`aCsHpethpHF%>UIaO7K4x952nq!$qBb&o$Je4Ph(FwXoyNi*J4y>PMZYy$b&mQlo z--c;JWuD_|9L7{ zQ4_Exb1|S27`)8q^rvE=7pv5e;G-NUCt%7rk141;i5%d!n6=}Ff510w)#0#R-*5Uf zZPayO*Y#2EF88ZhPMh$nn2LYvqN@|-fym;hu9n*9!2*E_se@aJxtZ)EwUtFMGWaCW zVXLK(?1mHeOwMiZQhF{#13Yl1JDW_0WiS{)_kO10>5f}zofd)I% zjB?Rwb~3~BrOo;={p5#lZFCE@;rGp2Q#@=RSB*nd!No&xI|oFdTS0+0z}8f0ZB_;6 zps0Blq*t2FyY{V1wu2XOm~g8H1OWVkK(yjRzD-KQD)W!^$<%`GSlr&!TFY@E-EO(P zs^!kU>HfvT@0;wt_0e^*R1Hv}JJ_|6Fh&LIGm~wK%2MNF9SK-LjwMRE&kR0_vzi!O zy0UXM9i5p3@8w8`&@zV7b&^^FKv|O*bb}uaUTXK*n#Zn}=l5lt_J3+1t=sR1cYv8Z z@7-`S=ilq|Tkfv)9KRICto`-EMSuwt4bl?pOHnT(O&8snV(1z;h%Oi#p-Q5=%_ZP} zW_-zUh*Mso$(@s8;$(^GOi=b#`9Ez>rLv#*NHVissq1zc&WE$#$a{D!s5PrI7roMI zH~lIk=HFWB)Cb(G(rf<&;1u?kG))6-_jl4XLj$^M(l_6-kH+t6drY3Mx_z&nKQF2M z+Duo|k&vboX{;mHEcGM9EW)7a#%U9tC2u_*88$exOqcv*l`Exi0*7Yn_~l>>ykwAY zT6D1?v=RMVK)!UzbTUqQaQ36v)|qj2yB$yW+j4LE*TkpIdpgSVb2{wz_BQ_X@87!V z0>Z1M>(;4Msd_FcEHK);mO1IU{RyXZ>E)zMu__sA zfY3oJcq<~LdSCt6D`1!Z@PFKf#cnNz$NJ{gd$r#Mbzd)!UiYu1RoC^e!WI6lpDrCu zBlM{zL8O`>DUF3`x3VP4d%S{xE@Jq=FQQ@XDKZ@3!OR}e=wD1z?;I@U?hqO zMGgU`zD#}9re}syGd?Od5hdOJygWO;Gd^5}8%}4rHoMbyT2JHS`KzRne`~0l;fhSO zjdJG-pac9y8)?*FNoEgU#He?OrW;>dQqIamoiC}wH-|=>E&5a77MMLXw4O@gUN zMYhXEt}+<%dDgT*+?^=&;J?_%6P*6wmVTqfbe`WY7D=lH(p7fOhhl|h;S zLxHl|Axa=H8Wb5xWAEr{(ndE0@JdONv{`{@On77EztxrgKmC!DOeV{x3h(zPW3V`% zLQr5L2aDUK=t7)HpI}{g+wPu={o}bA_PaN`-R=wCSs42hJNCb?iTGt2N@KYU#fl7I$I9QTcf9Z``VbefZ?fK7*>A= z+HW>ktx922_?$ns-95sp6VKgrxL)`7{ptoX?45W`YJdHmU+}G`E*0iTDw~d+Dn~1f zgsTLRkiooVupq>hWH3XXa;|A3Ln>o={c~rbp1mPv0uu4$@nuplH)h_AjH#fR8Z}*D zr9FO&{NM+A5pVVwfU##vx8(=^IGM+}pRV0$!Q5|r`J!KVqKldSBp6UqcurB%73PJ~ znmn8;Y#zdic^zqgkZx{(&=C&I27u*dHvLnv6vH%_zEKYSWL06lg)nrHVeR8}RZoYt zAM4X7ySW`6L9MQ@{chTx_tstP@nVOoct6yyj?esCS6vC~4rED9N@(aD5rj=JIvpd~ z1_uZ#k9a)j7pCAM9UhOaK&6(?bdElo{?bDWQ0r3H3q61g>7wXL4Z$=p*Gh+xmYMWj zw|+T0EN+YQYJYf~AuD_*!bOYy&g{G2^!`o0Q1@R25~Q1Nz~tVMn^&^J`Z+3w&zUZ% z_|sq~xf~%$iYPKc+fZNm*-KRZq>@@p{Y2-0G9=K%I5h<)T?H0P0ifkDbE)K3uEJ@2 z?AJGGPRAG9T*Cb{Z0$uoSJTfsV)(bVx=I;%JR_{Ij?USEA=EC*IR*A6ktXPNmFB2> zKS2*&V?j+Dr~$(zJlY9`W3%+f>5?(J1_DrGfVDlNreM&3ou&dGro-sQ$Udfzd$E1_ z8{dnqkeBg!Js&h5*x?20wD*_$X^+13)um%~Y5^v7b(*(GW%`T?P?`6&g6#{etfVt~ z27vKgM<`Tyc(~nW*=+XbG=?;3>Nlc*7}Tp9#;@oJKZ3ed5#~V4_z(MF#rbkR?cZzj zcI(yd&aS%^zhA?7n!3ww{rYKdzctq7mQ%MqSfL_yafx%fG0b^t4=D_#Fo_)LN^8Uo zmzA38(={?h0aI0qv-Y8j!URrLcMAGoGF{(%W--eN6AJi*hot7gAM4X|cYKE1KKT2} zLzRt(>*?*-?tQwO+kW}0_>X_72Nt~{v4)eME>=`s$l z1Rbt;Mta7ZS$gk+WgVtS%OQCKbP6tbYFbKr-}GAG$n~T?#>d=dc^-q=9W2}37i!P< zoBio2m*Vh$_H`w>lH*Ep|4+ktSZa)Uo&)HGNJ;lULYut;3couf6;OrBOk}1clI~_s zce7J_I(`=0C+4JeT}mTGR!8eS%?)UCO}%aaECf%d96+h(?G|wJRp1mdx?vUe)1ylcxuJ=H*UV;}3$CsrVby01UN@Gg4bF%f;mm^C+gTGsdxx4NJ79_@{d$mhrEd)P00Ar zE;Vgi`NWz6qW=Pv|K4eAKI33!D)Tzf;MU0_Zz z;yDpC0Bgce`P16=<37R^hqijYOREbn9|tDUm-y@-&&BK8Ie}f}`_QRGRU#E=8yV!# z@%A7)U|~1@Nu%^#R4Me{i{LwUaoMba0#crAKWm+=RE~|Pg+ykTG~J@^qOWKOKpAbD zVs3u$nUlB6`(4#X@6B^}eC|IlS$&H4^Zto?~dt-E3HIA57m4P-R%LK^HMHxa9ysk5~Cqo@NV4>)L%P$%U zb-%yVpC;B{`Muqb`gpplt-7r4x6ij-#4mFiyFk|i&Xx$7R}R$mw7_Fw#LgU8?vgb6 zv2hS1<%@=(uvxY4EFljV$7K0MrP_BzZbfA&@#&nTlUU=}Cfjiu!bqy<{OnKdZ^!-X zxm6#47T~GVHt6sB@~ny?zE{;E{hJlp?SU_obv=#jy1}?{q%VM?Cn%NI1I}gAz8@LX zJqz-g<5mF5v|5~=zAYk9U+AT(8=-2YvWa7tC={TTlBUtQcJfylMZ03JUV3ZdtGpfJ zJzNj3dwKet%(@Z#omp((om1Hbo)|~3y$2o>{m4coZM@1F(H}VjG*wV2QUseV*pWu; z2QQGZ!^#52OqD0F2aOh9xKMz^x>Dk|3WoNydYK_;n<4=1X_=_~V+v@t-_(n-} zREMfIWqUZReB}{q7T<5~`bdJ^S~OJ@9S($$wHdyIS6#`@@JUGPE z_1K`PNnb0P+({PGLLP@=OeK>$B5B9b5&g^m^!d{~Pupn9M^%4UcLSQVljgc{k6W$m za{QdZFMl>acF5gmnHvyYsC21v_FnoNMq{#Zf#P*N(y|*Po9vUN;JzOL=BDZ|V`ZEx zM_C)$Rjl!rCYH)%P6iapP|dcn-B0<`*hABT7VY1w*W! zIjLQMGT&Pstgh1|mZ?W}b7O}S1duIBYT01{whL~7RNsRG{7Gd5Y3Kqz@qTWUAbqA$ zdIZyRKAILl4?iwbFGk?dP&ZW$Kkc6?R$ss0-Cxn|^j?3C+l{>x#Z#YGkFe8fvHf#S zYd6twD(oX>Is^a%W8VM*iwg|o=(+J`&5@v zx570R+n}v&PZNt!4$A*tkHz>rUbf<8{kFXvE2U5Cy84_S@^18gUoROT$T_jy0YL*$ zBU+G$fE7WybJXcfthCsa1J+4^>*;Yw@y|2>xlOvil33Q0reeW?9hQ+I0r&_&*i^)l z6|#<03i+@_$l}fC&-%IcBEGw=Ke?USu0O}8dATac<6-|oU@aHhujkZufwU;h93_Y# z`vSlaH0Npts_P=Di!srveN_K6eNrj2LyYzKFJjT8u$zxHo*t1B7{O}!C$-to9#*x; zvwduxcQMvK?X6xkq4LU`JHD?kuD9bUJPzjl1)XwxaKXj*o0Ho`HsIil87%dp2Gi?) z2m_d4531c!iI)xuh%i9fEEGD;mCFc?2BCKH`VWariozDWlJ=Db|HuGpvQ=~f4xU$M zT?jw?!OG^cUftiX3!*Gg^5D||!W*a3AEIU`oeQCBGWcy(h&D;Y@1~Sp5J1>j*2$V* zc&1L**ZJtrSE=p$rrc9Mfk~Tn{SCM8vs|P{b9%c7^;(0*XkM#pS|S8+bC>9A7Tw^q zp`k^l=eIMq6Mq^6X-t4RgN>87)3PfOAfqe$Ty|OxLg29W&a{e2ox?v$@`C%fyrfOt znEk6Ln|Iw-*UR@{zQygnIc-n1t{2PmbAr33w|MFiyo*iq1NF?PCq?*0pZ0zn5DO7Q z$2hRNSW#kwS=o%)WLx@LJ4vwsM5)lSK0XW%0JcateCk)+M(DT>ciq&N)27(J zZ>Q#Sq<6;WuCL+MF4BiN$=y+_q}VctoF^kPy0vn|Ka?)u^uwPwb`%^`9V2UD)I*bf zinjOSUpMdn+nrSjUSn6Oj;U8g9U|~`W$M9MS%X!K2Dtg(cE}h#{WJ87^rM$5(L@@HfOLiD$;l^>c*+1I3NZCU zk_jY`33_REy$EbE3PFE;!D07LzzcC6`T7IswPnPP<@L z$XZRRvE%a;UgE1%EofdBg^f-%rpW|0u}OeySi|4$)==*BM_o4R=^tkQu8!y1`hN1K z^3mQt&0_U>PIOmzh4iy0*qnQW3Q5-2wE5M1B!|aouUtrK}^L)Mt+~v zuB)jCfG_4{6Y<-OP#SqbwGK%ka_TcSe`X86)z8x@e(bt3$~;@YH}7Ka*ScPzo?U zT%^3vG@@3VM8lb8rxt><5pIGV-9Ed!Udi&>p4;PlzrL)>{kj%URsH!^Exz9jd`Z+| z75tmCW_2m~!Momq5P`oBK4VK#Pd^V>0?`RhBSNN3nvu!s1@;tYt+56+>{=8RBdwuUN@4I_1roTDiT|10E z2H^%?zYi%H0DfMBaSq%eAti!uphsYr9*fNIDtPbQ;itkdscoanLbyNaPwxOeTNzrU z3mFTRy3_sX*mMJ!*dJ0PaX-*`H zNXjZS^!w|6tMj@wU#}nA)2^;Brv9qp0xDIlK4(zei&})Av(mfH8EI0N1zsv^8#_+o z;!T32*dW`nDSPU&RREGkXryKubEQ6c-HXZQd7%q{qAc1%m6f1)q?N5pT8t{Fk&baa z-B^C(XY&nWz1r@iK3u&xQoE`27ivIoVTO!EfLLrp>vdrfQh{)@t|Bk1DG&Wq z{S>RsuAz14`*IXFbN;-)dl}a8@R8Tu{jmhk)SUJ%2)d+Gtp&%U&<38GO@t|EEL?~1 zU@Qm0dj6Y&&p~$GI9fMQB(yVA@e{bzg2pBqwP5kR>RO6l50$|tDU`zx1OA*}ZCZ16 zkJa<$%6M%r#c_KK@vz02q1OO5kT-*rKm}xjAWscVieA1 z>{dy~8_QdSaiqrLsHXBeg;5;amlUtXl5KrkN?QT>3Ex?PFRCfi{1ZQ=RdM$g+h_Yd zD7(LD>EGA)CNz3?ydqvL-Hxd_?Og{b26mge!BV|$R9aI^$|exfOj&Q)#U!z5)1OP1 zHxzV96rON>7$@;rB@i9!T=zo(z}_Ho)_tw2N>Zg(bqcYGejmT$A@Q*O?l-5`u6bfN z9zUnUYkyU8Ul#9kVHU-S)U5U{j$L5C6}5t87_-W3kyITOgojais@8(%+NcvfVte`* zT5LRUBVg7k`hYJ`y4tmf#aKiSXrVwT5l^Wj0C*s5O29O~>le*x(-hTx-yDmhX&;B` zvpzl#-_5EztbDN)Kh>P}F36_^Xa?Aq$ljo%0Ge3Fl=xJ>H!1f$9uFWjq(Eo;6j&w= z-7v&)m>hn$wa=|al&Ms!)gWw8+6*ILcQB%Kg;Jqy{jbZPkHy=(4iA4Y$L+Ox#%lHc zo{PHuZnZmKl}BxliRtlzJKq{=2nIsC{?^1 z+v8I8TFq(i#=fU2`3Q#Ra*CltxN+H!04F_YY{Wqv>5!6?#Lp#_dGNd&@V*pDo764` z_>9`pFAmH@xdz$97D%0~4`ZFjN@8#H_E(!vxGE@7ihA>?cXeFf?BV@T-;3I;)&1+1 z%AaaZd$(h?Gt&bO;ZnseS{A=7_#N>JRcUC@jvdTaEszI8t8f!}$J>KPO;vYu48RN& z4WP$>^t7S_Qou`tKuDb_ISk7C`+o7b-JTvoZ~RuDclY!C@HF2_zQmgfAi?3tPKy^Ht~7w&$Z1?nvIV(_92Dh(dQ* zGtmn=<(M!gol{7E1Nam=4GB9EhYc@^@aZ@pFm&0|bkw`a?lTHf2~k&NC(0J=4S#YI zK`i^B3I&@baXM-E^^0Hj)uVmYA9>y#UQWE$;EJ``zPG2fUd!Xs?Vp;{-W|C8@)&?9 zA}yv_P@u+!5#C435q3ZCjo~?*^aTbon!w%9PF&bmKI^^#%LQJ@#K1 zwHs~b1fcu%2e)Fs6?JnhFSR|Dm*=~9y8Es^9j?t|8xQA2{xGM#J2Ha!h<9?y`7z>@ zfsz7s`Vm>b1AP+KGLPw@Qxq8nMFLR*5)I(n!z4aS2vgXcT{I=LgB}dRDf5eK>Y-|K zUjmqm3A?}J&C6YNIt26mTn-Na;d^;|zS^_D$xvmrP1OgBu0f_Okv%J$noPUK;?HJWW2@B0R3NwiHa`7# z{p?=Y`{rA=#phtfbIzrdoI7!8eJ?mb?E%g} z`>>8+69PPnPA%+@43pi-&EUO?_+m2RP?<_<{tQ-96;{cXcEv{KUu|z&Y8@}G@Ym0+ zvX`w@yNjvLJEWI=sXt5I1!_)w*QG)A8ZiVxL?(b{ES|)BWUMFBT>d*OJ?ML&W4%zw zeO7BQjS&>yPOe|cZfYYWZM~MGks4};+``sG7g%?t=$mm6NaSs=jH*}h~)1F zBop6J$$IMj*f`OY2$?h(x4?Og5!lZ{3^aaMeb#O23;)A!K{d|rbG3dQAJ^Mn9xmI% z`DB{Ip#~ATz1K_iT{S1Z%ONpkh7hS}nZeFHo96yvDYs$Yfg%YY)0{^jM?LC+u7HAE z7!h@x^nNJ*d^)KU3BIgUm3?Jd%qhtYkWMRG^`iS(KX1)vv)Z2gRXo;yy*h-ecsA#@ zJ@{MMuIr`lRy8NSD-zLIhjokH5Hz*UhHe}{*Kz(hbjy-9HWOYJ4BrErMo>H2S8A3S zCgV%t>EIVrDC`@=`yxcjMmAKdq)%H8Aovbx4V!blC>{9deMCWdi4a>({CXpVM}Id3>DR9xtjs+;8IWs`-tTzC5NjdsBOS9AX0XQ!(SsisB=FGPyZD=-To3nt=lpN zfE8VFb~+0soU1_JMNO|7gV-9xgt$igZNzhP-5kGRefbtuxj%i{iw})Gs`jdT##t8VJNsr>eOIWFR}Iq_Z1 z!OhWxMDtLdvA?l)D+l_KrO|twM#jycM~?`IPe1l5+CQlg{jc@u|EurXN@i?LP7`!QYww{RpB_h_}d<$VspQT+w*ZfoL7g7ILhjz-2QSB;RtxK_KQW{#-7)#x@0A{;3ZJeWI{wdyCrN>d!`1m*(oOYkLZBbCidr`%N_`zWb+2&So;l z8$K0`q9qd@iV;sDXep>TGR2r9&Si{32h$I}r@UZ4%1Lj8$VNJB?7|?xw7^(Yr*inc zjZNT2HN6g1KOz2U*J|~t_WO-f_v_{Pe1zvtSmeyF0xI7ui5I9j@m;zNnwVXV5_}<2 zz9)Mbm5nRHApv@FM1J^)G4HUmN4LDI{G$5`}wWw<= z!7j#1(x&bQzv$gZ6_*&A?d!XV$B(WLU;8nycCV^(vk1@Tw0H4fRPhD{!sGUc9EsZ2 zQ6VzwaU3Ex;h1GCTmx?IHqH7VZo9T=jP#>{UUss)838JVI?##)FrLetnrE0U(`VpUW4lO zeF8*P$mS_^BfyQd3Y1vU4rB6q(3XvJ=q2wY}!1XIULDcV_u zv7?UN=*?)6Hzu|9o#qsHXo?c3zzAQ|!s*Tcjdx?=tQVlgy7<|j!Czi}{c^?8Y?QiG z{;HeT<0|~!`P*~%Uf!QG@P&FB$m(>djUcvCIpBVfPuUxgr5t-X7)zNYPxTuf%&eqB z+p?{U&QN}2$o;dO!&BMzqU6p=>~Lq_EE zzR6R=n;w|6sTBfAEkZ<6$687R+&Yx5^GX&?UxZQqUf+sldyw&^!|C`qDN(H|d2id} z^$VQ;d_Oje?>F1M%TY=kx?nA5ZihsxyphDI*NWX7Bu?z`r)oW=Y8|NHtqd#u0C~Hf8Q6c?(geu z`*<(XqdD!}%t3H4y66)UGNT;@b9-Tt$4%zNCfHx#xGl4S_cD8_hHL<649NM^`o%uk zvHgem+3`={-2#VJKoJ%w$qQL1cTq^83A-a=Z4`wlSA|xp+M` zr@hO{2>5Cj@d_-z;{~&0lTsAU0wc0hDR@Hc9zYdLRncF~@z&(e@Nla9(y~Q+ph`%{ z^pmH*M3BBO@xQ?5X=oLW^{;qAIFx6xySuygkJEQ|e&LH=&$o7{V}QJr!Tr9ayBQsapl2Ad1q}Q76EiAy$=YO_LgI z@c6Sot+{+o;e3CdPUf{0hf{f4uWvh5AtRcD5R3G0PJ36Rs96sLk{(%x(QL*N!3gc> zYC-1*##ZIM(p}`WEI`)68Q81E|EhRV{Ey#Kxa zQ|tR#yjPFszCC=mVt;Cn=l1#9DI~l>&X&Dt(5=5X86s2R0Oo2s=Dv}3K0f!@v~&zg zmIJ3o@%~*${pYPLfySrKUnm3Mx$MfSKo-d^CeTRHk%NQyg`vc64$V(_0(o|Qd(`_! zb@TSRGrL{Ww5Pavif`OD*G2IHHK)DH{vtdw7NcW%9{VPYU`9D3-(i1>4!8yRA@QxX z2SY;e0hu3pRgvAKHhUjb<8qHrfiJ-}8s*x$#L+H$VD!oqbV?4t!<)jN5xI{3Qbj53 z_jTWuHE_6(;^aW%_DkYDYEF9>(Oc4KA|>GIKRGFZ%xr+A9S8l{1H#Evgd7}9_GS+P zpgB>79uamDf6`SIzY@n1ysvLdpGz;w@*nFJQLs@1U$Fcge~{{ZX5IK>FZhBHuZPuB_$EQ(x^t&F3=3q=aKVF@K5no}}cH9D;7 zIN5$(QAfC~fMRNLXQPy^J*UxplZ{PvM3x7)nD9P2Zpv*eyxr`BIBjmX>sCKsVXwZ$ zj)pvo?>8s@G7dOz2(JS+qZ>I947h?Q<0#KJj@frKB+1?>+X;otff&mSAVL?r$@a*O zR)!$)VL-%0J<3?XfT?4&> z^efQ}T8?c|s3LX1o;6L=> M7oPUl;3eV!0D-dHtN;K2 literal 0 HcmV?d00001 diff --git a/testcases/create.json.gz b/testcases/create.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..d6385b44f5b282874c2e877b7b5865da021f4db1 GIT binary patch literal 5810 zcmV;j7ES3NiwFP!000006O~-aj%B%V-S<}ry_O9I$siftar_Cv3ywQUfaHY%!~gDc zOWs(I<#!9!s3Ef}BS}V_A;_pd{q~3d`t1*Y`2FwuFKhqp_ka7t@9IA(h;#`-TcvoF zc8t^Ai3H2yY*9g+8JYX+0&{Bi#R&gd3#&Vj2ll>y3`CR37V?)bUd=N7JgkTJ56%mlxdR19%FFQCp=8KT_ zBc!`-Z0oUgN!4n@<&aSm=h>2IELxSJmWp&jd9$(n&mo+Donxa$;_8No8!^9#82&k;Ro4nR%aobN8s3RYkx!x-ofs4CmKuon z(0Zm95#@7RZxOSOL;?_KyRAIDva%e7#>NTR*}YJ*OVd9h;-`QA?ML7bFau;912F4G zCuDu0JZsgC*?F0w6)A5~6z3Pfj6T6E$Tc-u#laX?*J;?V+{Pg3%J1%injMA5+0G+h zw~a1X=C1oDefl|2%i8xvkvU6WwdoZ+=``3)7H#62kRMp4`4*9#C1aHspHa_6pRTm` zrg9zRjHl92O4E1{jY&~?aeUif2%{)O(Y?p0wCf3%b z7O`~E-vOIGv5fUC;vkDEwxR=%05+7wCO`1yodQ+ZA*FX?-yG!!l<_rP18J?J7;Oo1 zLpx-ToL-AFAroYP(nI;UzcU1VLK&%R$PMrWvfY%`7<&VwMDIkHEC{UGVBpFw;a=FvFS}G7(q@==Rj6THF`p zSp>l3nOQdYUL2+gbBe}b96o@5F@ z7T*}ZV1COCU_C>o-UFfo60UgI-~gPEQwNg-y{6 z^qI(Duwg32O6t+H?D#91IZluV77|wJ8sSG|LD^2-M|OddcTKj1HTeZJGoNUt>B@E1 zDys~c<)55DRRctI(KYy}9ZEeJnYpU(TxUMfOq=Uj^@tJZxtI<^3(Syx1YXcQ+qxchH67qqD3c5PuqW?~I<`d4$Rh#voU33>?aD8$oWcCk3uyh1((kao=f*)O7mlPHp49SW?wHp^U4!eLy-YiaC-5m$v|uE ziwc`p4{5{vB`ALWUg_o&&mb+Yy_k8x@~*ovQP&Xhu(+`nyRx&BGLu`qw)19{pLlj> zLtCLUcNmp&p0Iz=z7E<(do#cqhYM~b{JYfO_F5MQLWRJ8pghq13W;1jn zIvtYRC_BHxSr}kb71fN$I5k2K(V*~V=#cT)VS$AeY3>)`%znbzz0P647+T#H1a=&t zV!{qC!`DidxHiLZ8a=-!hrOWLwdiaM!7_<$l}m-bMUjgiY@G+j!7jjYPw?Q2h@W6~ zZ|-z4Q$e%4xU`L6Ax^V;!g|*aS++tB-1B#6u@`M-ugTF=5_po`sSFOoA^q)!51V2g zIpDd*XBT~M?${feT?Obg&2pUC3Di9ZYAO^R!?Ab`KmSDL^SwONHM?wWUu&{22{!dQaZ{tx11OPBzMb=SzQz4&N=C6yi4#(Fyc$7-5?8<1` zU{Ok(bwD#u8zjZw-HW|A&3iM(mKFR|S$9qfzFoVj3wfh(hS8=HM%Qbf?_lPMNH2&Z ze339l2-#9>5_G73C}VgSW34y80A_q~n)>ROmsvwBwyZd{!8JRGIoh3O8tnQC3e2D+ zxUU<>pJ*1Y`!-dvFh1u5EbUByN#Y)%n2Zs>lrZZUWPFzpd}*6q*LWcO2198IXCSqq z36}>sUCQpTNb{kkSmO5z;7>5S0*kkL!bG?R+e}NJ1nC`>^PVk^p+HOY4mtRpS@{#n z?w1@o(1T#C!H2K~;WADfEz6kk=WbO){1QobIdtt|pQlpeN1R0eN92n;J|h@XF+S9pWa*_}<)fmxh^KU9D~$qiWzC zp%s>a{0qP_tzAGRXsg7gU0(E4-6xK@Ys4uN&c7IIfSsTh_&rep)~8tSyLx&%0WrUq zoV(p*UTe;zjtc3K_L2=)G52fB+YyDIvsHH8Ty%{mCdQ#-*;t2oJicM1Lz&HNQVtrbZfra-x)4ixRv%Auec03!<` zf}fkJ^*tZ`?On#T1S%~DaDjAy;&fiC2=8M-^GuLgE=LLlLsDc3-`e19GI%FVO&@R)=thZD2W?MhoW#)?5!Drt_)<y7r1KC zC86GYH>4f*H^P+V{9W$)%U$MG?oI81@qWkyPoSN%IH`HR84-$^ScOi-S1l$N$@EFsvimKskB zec{6q^%}n-Syc3+^{*%U)B|>o4Am&s^b^R!k(cIqj9);qaC>8RS4o@ItTGcQ2bJyD zq6bZvhEMR&(>+^1z56cO!$p|giOz)QX%g0Vj?e^zuIN1p?3dH7z*u{R5qpsw;r1@$ zy2{)pC68k0#QLLMoy(jqHlS1`O=XZ2Ujcg#mVW?kd z>~Ilgbid#*O(9#MS3;QEn9(3dpVvyz`K}Rg70&mxH;eoLv!8fOcm@}BtA=YDi(?qb z6d;^&d$PqZ{>KgSi-;F6yFdJFF38jH2kZF}4tp@5a>G6;)UqkiH^RKXqL~B~+A*s8 zVfVB!sw+CUket$9mTb@6=5ER_pqX55GWmW>lPf!W(oS7;UMBCM0(ezJJ_v-Gcv~1r z`E}#u()+)^hT1CRSVu?h>Hf5e-43RUDz3_D`?+sVvv7YA@>7}JZ`|g14A;Y=&%$KX zS$qLvV$o0*fNz+ZonO>|T+rtLxnr)jg8(AV-^m@Y&|J#dS05r0e*j=cNqaNSMG_X*i6Tv z_@agvb1>`@j@CjcJ`f7SyL9;8hM?;Rz+HqwXi_tfzP?+Y+4!0R{QJ|QD~|xpr38AR z2g7<`}#g!^G!4K$;gl zN8mH!^E}D51jpNXe&-6hOac4^xm8wbp1Pm=#OxixE4*cXC9m2m3$B>=0&;FWe$Mu9+!9?oib(D0B1YQ<#a&)IN0k% z+ed573g^WO;mahz{jM0$F!ma{>~fSkk1`Ba6{_A)URq?GFyT4gg#2uu$#t1-!79yt zvW46QphXpZb-|{Pt+k01@O8MJzCWLJM%Zj1a9CXjui4rWi_6ikI@Pkan898D3a(v- z0q(CC^ch@r^V2TyI{Ut|TM?|=l18bw+*T-ce!tkK%QV2fYpo-ctTK89S}@z712e=p z{0B{%{PV2F*6`v2f-chl_a~4=c_DAKgK~!JoCcz$pXOxrXWC~}XjIAN1$bY^0e;fZ z1w}m54c1L2mSrV&oUxjjqIb5;1z~>ri&yKHaR5#C?$Uw|Y)0vDh{v=;Lu0cE3(44? zN9)GVk=+Y`xy%FHIcjyWvax^F>9pJl3wBrVJ5-HX&V~eEy5+kXrOQ0P{h|d18vF#* zHkF^Bd*JCdI#H4vghefW^6SOTvz7u z;(7jUB;bD6atIvpMw0E|@$QQ)^SUQ_j@2<-#vO?J^Xg@BNo&+>Vt&r9qu-5hkJ0rS(7(;7677 z?VvK=#QYR%_n1v`bGG~0Y7ghAXZ#IT+X*-j;a*rLl^!2QL1W6vl&k0N+p zGBhpYFgX|&N$$DkheZU)et%#`x50q>)Lr9Z4+%?CZH|&65+Ck?hl9?L9%0*Zar1>H zy-Wt&JIWEhokx3a2SDs;d)HyDwYVxK4{@>EfFG}R_F_P<#rL#cp}nC+p?iDAH{e3@ zrz8`c-2nBJMD6)Pt6gRTe$pCcMMZjYNg+){BEE;vk-{rXj&K-IBUw}VZtdwZ9H8&L z(HWwTaJ|kMYdo!<9rJqHc#z!DXm*?Gwy%!!Q>=w+3O&zf59F^&WVm+UCAKhd5JpGU z2#PIKqrCq9oHmCDl9gH`77#6tMPN_B4@%Tn&M3zgHuP73?J^$l6U}K|suMtB2QO2M z1F9GcflZ+VCa)a%Q6;`OuG@S7-z~%$R={msw?1A$XR|70!gz!C=kuIbTCVK{^<4%8 zeliBZ!??iv8^=h4;$Y!r8q}ceKoJOghx}IlQWt2y@68y>Y&`F@d`n7VUzW%>@V? zus*ktsu|fl@AYfYc8gy#%oon)GAD3<=+x$1YI)e(V9YY|-0_G^o*a4^K85NT;`sa1 zTAjQutY%2O@;0Z_^d(XQI*a8TYAu#PMZW@UmqCGhAGC=xPlrc?0-2@?gM(N6yyBbD z(qwOnj2C0fmqCG_JTI@ODcU~Sk)|=Ih5!_rKMg{KLX&RkKcTH-zoIUJ(Ij~0$eZ;PleZ081 zH{;s3SpoHv*%jlvuZ2ZH@~WwFw=RU{^7HSsNM{v?LQTAhd70$A#oeI31OK4o_YxSMfCIdkmQBMzsw8V zpAzG%iB-lzxtwsE(`G5vn%DXfQ->9zhWrM-F9QQtkAZ^ZFbAlg6@CnyIZP;}u&r*! z;2=$RetjQ3rt7@GJ?1lHa->n@3hod4nc4%cQD`ug&oq;#sJ;3QYH&i!nn?i2=sYF1 zD)r7j!;l?#{eeUo-u?=xT?Pj3bCsc{n1%H7%ok4mxsKo6EMj+P_yxh)O6M2${W32g zcm7EUBJi0RkrW2}?*_JLCEkG!5=R2}mY`qY=w)Ew-qW@r9(L2N11TRz=-y;108^kj zDUFpzwn4wB^~=P-UBMi&`YAmRdT4|A@Y6}FqG@@!h|a|o=$r3v)95lYaBt@I`Mhym zSO`H~Z!@&1&2C0xR*p=>3-2SxeX57`=n55p&n(G4P$|g<5Y#`3fAa6auzn^U7jy6?KU}Z w*M=QFnpyc{Y?Ac+Q#+&hS~JuKabJcslFBCce=zO0fB)@&0ASAxk_$}$0H%#&;{X5v literal 0 HcmV?d00001 diff --git a/testcases/create2.json.gz b/testcases/create2.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..47bdeba4504caeb8f0c60998049e0870426c278e GIT binary patch literal 21247 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 literal 0 HcmV?d00001 diff --git a/testcases/hashes.json.gz b/testcases/hashes.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..67ab3865183643dc5fef7512ac99471573b4b1b8 GIT binary patch literal 68270 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 YT79b@X8C{qumAIZ0})wmHM}VT0F3DDr2qf` literal 0 HcmV?d00001 diff --git a/testcases/hmac.json.gz b/testcases/hmac.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..2c129d24bd52509178e52afc47983f936d8497d0 GIT binary patch literal 34364 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 MKWTYh>Rk;10F|CxUH||9 literal 0 HcmV?d00001 diff --git a/testcases/mnemonics.json.gz b/testcases/mnemonics.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..a6251912e0cd2074ea1e0f46ccc02fd7e4634d76 GIT binary patch literal 857561 zcmV(*K;FL}iwFP!000006YRaolHR5#?CZ;S%Jo@aKE9JYIpUa8 zuDF4(2xmC?|LJ#xz?=zq^~Y;$>&yDfb!zVvHY%Y+!5@|&6mVjg@t7Osw9^6+trccc z1aDX(i6QVqt&K5Cdh***;pRS$XZPipU%uxL*YmNgzI-eB!JjX`a`FDRLs;ZFp%`PS zkTM1%lo+KM_e9!&NP@7!B>02|B7(Dq5KVP(hB8NeVu@ptdrQ2cT*Jjnft3oHhr}ut zq;$#|EwM@@!vQOaDOFmzfZ^Q+C*iltIvkz9zzO{?c=3U%k4wFN+`9e8Ti_dZtv81h z-udOs1F}YX&W&&qvBWsznF!X(Knc@G!uetYX9o8@aR^RAGHJX_Fu@6Yxclc}oi9H= zDEaO6=HUGE53fsohCAHc914Ff&zr;bKi}wo9wvPK2Bs9}F2VnNLwPg**x0WB=Rgrl zbYR?RrkTeifzfvaAp@6TDWZvkn@ecIEjB?2VwmPyQm+AV0)|V6|2Xh@bJth@A4kT> zC(gjA28(^70u@$!c!79ggyj+m9fAmfI|Soq6Bt}cC4!If*m!RLdE93_a6BY@aaR|N zR_9S0QPQQ;>Uuh`ys=ZatPE7mMyJlUK0fYW@`+EAR*qlSQMWsmuX@LIvYZ~9^yVLQ zw7V|vlHhgGtlLw~%4;vL4K@W`2fSdn<80Ck)7|f%e=}b`{$@Bw{i^?{oyNwtp0xis z+T2{Z+n?vle1tuP64L2AJ$gImkF z#GW9H1&lbA1ToJ&0&Eh?17?h2Mv||wi2fQDzlPd3SR|MyiTVx}nV^6a4KtJ(t-Zzo zKg$@*n_z(nEK$M}>Z!%TdBBxOf)CVTVUxhQqVKS%nDP-@(n=RJ65PSebJRMbxffCa z$s{-t3WyNM$7AOK=E5p%EwWs>&#`!0^;XsKQg0OKa_aNmcGu4jBlO(a>0HgGr!nfv zRfbxt^wyuRiuALDD-FYmA0c9!*Zf3e%Y8rAV88QH9A=-7~IJ0I^R z+wtkD4!H5Ub<^{rU9|Y|JE*+%Tl;pabE~&P(53QKbGX0xgYwsFF%HkuwFyC_{n*b= zvz^LTm(jUyZF|suRp)hkz^2{)DjgZLozJ(e>vl5Qyr$jGyk*uCyLAUr9Ba?v_fSdk zzfuH!Z%_GsbZb7Ft$tM=d)IbrG8UcoM1)H-!#2xH+pZt$=gy}9&3w_2LQMc`*-o*0 zxTNWvUW(IYfN5{oE4FAu^iH>)VKL83k#G{RUU5ZkFDI5-W1 zEwwWiI}Feinh8M-$hF_;>>WHQ`#vnAJ^-Cf-@;Oo1Ss+MdGHM^1q5hBbwZ3|1W^V$ z+=Kd)5W7V%3J1@Wq)r>5kkJW^SH(pFKxW_rxOoRlxH?e07OtCuGhhlO5dT55Qi$3D zv^a$aZS_Wbai`3V}NuBsqt%}(R?>^$xsZoM9=?xMyvEUli+jIPJ$ZK<*j*A98ZP~OS7b+`%E4QJyCb=p5*SvdP>Ek$WJpL4K{@Z(Ca)@}$ z5U?>8fj|P^Adn&uCbdV1Lp<}A1wuTHcuhcZg5$w57#I(b1K+C5zY0vmt%NA--UoD` z5gWXI8_=0B8hJ)I%oGE2i&2bB;*<{oYeXG||2GI!3%E)a5-p_$g-i*B5TRijz5^yh z;D`uB2rxdN4ID!xAcG-jCtz!wg3kg$;9(v>;3vYv9B?=QbwgM|9PaPue7S)@x?8Zz zNXa$U0IArdBcI) z?6vQ&+Mu)l0!;Yl|Nd_u`20_Ko#Vm(L|R8^!39tWi2MINU&V9`0bPqeProq5b!0pT z78-&y7s5sMv($jSaSr&MY8SB8&ciXBaL5KjwMGPF2P5H6reDGj{(PN&Q7Q-m!9K5mM!;*kGFi-;bGVw9f zpkR`t#0%z~^u}>x8C*L84fJ1~e(}tJfd5XAbYR4h2lEgF5R4)r5mJ)?oV+3am zcNkfas6E9bY#qF2*hoO5^T7C^a1tTBw;E%Z0~`jIQxlblNF za}+b;Fmqse5qXD2EF6i~8>gtXibqr`2&q6Z9;R<%vE-OV83CR}x+HontPBkZ5e*#=}>8Ia{SKH^${`l%9|CnPcA zALf&4HaYc&sln}VNcE{vZS&T+b?q-}+xDQfDK>Qan%LuDtB;q(6zSmc0@6Ok!Jk5H#denX@{X#KSMrZ`e3qp;Cdk)IlSOOwhdZ7{}L7G??NAHyf z!Y2Zv4USnD4N?T_AA#}DreA)DN@*Fl*3h@8R7w%W5d<5EOg>1U#9)HefG9*bcy7dCU}!|vWJ^5>NLjhPfzTTA^(?sWxs>UTU}(pF%1IX zJef&051z_abGEm)>8d%UJ$1+~vu8fPiM_t_31&Sc{a^nh;-Lf?ZRZ*A1}|F zCgbSR8ircS9`nJY(MUUo0Y3a{`b9@Aoq$@BAPx{{YwnZ)6{0XF!UzeD0lt#VDT}?} z39zacI%@L-U}wHz%b!iZ#1${k@%!`(k1K0Zy$#`*a7%S$_P8v}#}=LyBiN2wy5WZVJK>A)Gs?*J-{0q%_paX`XAj6pE!!T%!+iU-_vG!!13vQ9LJ zD54Rv3fx6vIkJWc@wv}M`$NrS%|mU`J-0V0_<-)NzVCD!`>YBDtsPbSwdp^_@wV-( z-C!W^+hVJ$!K_Pa>j=-eT+EiOSEI9=w%y$4GMiuK(`h*6ch@Y^%bhfi?Tgrdo*!)N zAp-7{U4qTpAHqY8dZN3*mzLQKYVJ2XQgoVSvG)*vqcn^w`AP~96NM^wPzJVp39d^UzY}z<>svFzS3$nt)dYxWE zXFS2p>#cs7T=)h3rC4@zxzFatT?8Y;$CKYrqxy2vn+@#tHX1bh>z7=Qs>`cOYpUDnk^QfxUmU1O zqfxXA3HU8TK~NDDms$|gjL5h;Mm@Z=QY2au%0D7I2)_gd&7xlgrh=mZgT3cV;ZfrL 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%0D5nSaQO2Nzq(*bH|pv`rSCM0iV(b7Q1YN<5jD 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%0Ae|yB!_fJdsy>CabZ+{ZtYr~)4jjm+hIy~R` z#J_tu|MH9%-*tYzdBu}&ze#=b9pnG*`k;H+w|>*x?d;pn_||R0xg7qX@1qkgg;D0L zrCtCYw;r+}ix#plkqY|}aBdyI0gsME9D*@;I1Iu_NU(o;oBaic`9J^d>)kQ5*ky@x z04CZdI7%o|AK*IYNcgnj(MVy?Aj-g#@aYGEf`7a( zL|A6OGcx+oW1brUIGsW&)FcRO{e<_1Ph^lIQKl(S2A?Kc>tq>m9N06|V<_`FSjs+1 z3+d$GZ>bRqMcurQ$dm|0iC~gpPvR{*9U@RggQ|n@BQvzk13KY>jsJRgjJ^2DcL(>w z&2j{2nr-R0(z3SZ`<*={p*6yO_s^jy`;b@`dt^Y{|vP+cD@6#8U5TB z0zeCRf)T2*qsnFW%>_CrI6)8-KuG{>001Va6(+UGoMA}6oI#zT&kB`-b6`yxzFWfA z2RNFL^_)+J0pVA{3E?0$2gsIqr-SNW0T@2~28DZ}*$0Ai?cLkWQas!m`q0~#*QZW8 z7PZ5up#g?%EWst+&(OI@sZX_aB$q;!+#r z`LO%bEuD{jp}?3AxF!%iR1nC62GBf-2GKgVXz&dI>Me0dcCf+6i3YU7ur(6Du<-ud zeW71Pr8K~#z4>^V2qjfPmPbYC$Z$W|3og-I1!%a^iQvXCuy!cA5KhrsRA38G{ERY| zLKJ;o%`pir8jZ|?j}gidRs}esP^Ka80@o98R5`G0G?gO38&qcnW}ci!56kRlQMoVK zy`t;N?ixz;(Ku}nqOs}JOXE7P%KfG{TQ&!TjJCVV_%uupmBdA?r|pikhrHBy-e!&b zSRYS1&%u0hX>R1S-;(SycCj^U>fII9qF+CW%Ejx^9n`DM28m179_*(*rE2TtrR|$~ z>GjUk{q1>a$lHdN7S&Cz@1tg3{VIl+yEvjq0%nP7@(UB@A^2};sJ_dfWA1odPBSdQi

    >lU7Hm>$v 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%0D^yNZ7cwePzM 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

    ix9a^3}=dIRxJ(p=d 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 n&El|mZBaJ>r*Ikh!5K@J^B3vQOj93$A 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 literal 0 HcmV?d00001 diff --git a/testcases/rlp.json.gz b/testcases/rlp.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..b39749ce4f6cedcaccfef54c19650196fd6dd075 GIT binary patch literal 1763 zcmYL>2{aoB9>y&xwzN`5)zQWgY~8}dm5HJ&43W0(BN4Yai&k5=QVfD>#aZJBY1L7T zqAA8v$}~YyN+WI}2#qU_+U@La_y2qE``-KB`~5-b{9J#X$OhUnWWh|ZW5odgUnyP5 z7;_0xdo^u&{%1gX_lTzmR#$ypG^Xsd9gN5U&6{Vg=Qa%>7R({$yS!9;W`2w`l$sUg+yhJ+0=)0T-TCsQmqz01|i0KzUWKiYbP+Kn9Ay18jmV zgMP0|B zzBsq9>?Dahx713&v^}BwRl(Z>*0Zv`6!3Ue4RJJ>Y+TYvtEt>R=k&{}2Tr7LvZ_|6 z$N-7MLd+JTQNC?zPF}5Uy{inX23BYT-5pZy?zW=7<{@ON&`}i*E?59IUkFrdpuS8> z^c*j?ra+|XhyXo|ePC`APPQlX73* zSC3R=$eF@(ZWe5M`j-RWJI;QxWIBI>SbK0(fJqOB42)RRUY=T5w}c2sp8->7GBIl` zqNrzz9ZldbuFdTvQ~6+!{g`52iqfMD1KedORGNyCWJA_0yKXgqm1L2f`U(&9a<==l z1dANavv_ZY&8l5720LvLBbc;^*U$nw9H@OM#R-!kTId0*gHd$HO_`lb)G46IhPX^Vyy4o^k!oI@v~9B3?*ZVzXt8rS%| zWJ=Hq&xED2!Q=_UZM&kQx|z}O9d3DGf%p&Z!PtbEV>{6fl@9jP>!;)q`&N)W>bHuk z0$=i$nGi#%<>{31Lk<~0nJGz=qT6o;o%s<PB`4? z_-lWjM#~TraoSCNB9X2skoi

    YwzT^RU5rRjj>OF!XnwN3q=R?q0xg7 z%9vc%VX>N*1bGutzNaQeG20L~a=$IgE=2K*_YJPat~)}L7Ph6x2Il!uP?Pw`Q2v2coQX0?pL#O4w&)thEPAeBG&( z_VhV3dzbQO3zae_ZKw^XkE#mXDC#kGf*q-abUvvHf*1EAIcMVUU(Rhmi{Q96zvUPG zt*MVMmmt6K_+!?uNs67i%(s%6(;d}}8_6|Q-ttS_v608erGEaHW25Z#2NiUS!y7?R z(9!t8YXzabM^4Q!cX|I^l1~h=J-424{k8|pPiJ&J-W}u+koCNZ+EbRdF1$70tC{abYmB2G~6XL*~K!}a7>(if^GD2C1QBop&tWeK9FWud9rRp z+(@;Dno3-qA(#&Q=KAcIGC$j7>&SNy+S$~@erlXAl}xuBh02v&E+w7sKE8Hba?7o= zlZ$g!)|ESL!eyc7m-?jJ!~;){vOE*LsfP>DrnP3EEdm|$<`4uBZ^i4?b8-C(ew$;Y literal 0 HcmV?d00001 diff --git a/testcases/transaction.json.gz b/testcases/transaction.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..3039ffaa8cd8063a6ccddad5fdb973848ad40770 GIT binary patch literal 346037 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%0A}Kr< ziE4uuXR8dbx^)EGgz-muS1NP8DAHJk76s&w*=!x~5@Gq(x`P}V+1fb<+NH#HEYp8g z@8~SaLuA5+aLY}DkEaspH~-a<8|bdK^zZo5%+H(d2+?7F($C#d4!mk(*8T@=(VuP| zs{WxZ*5jrrT<7Ua%ulzozYDZlXQtd?$bsybhoe$H0zH6CI3-dm8*Yht3~@CwT=IJ z6@o@1R-B&Yu3B*f2&2B}22Bea1w&X(AWdMBR{#pqZ#YzhV&0`h$=O)=ip=vG7|j0`>n|X(fSYrScMJ>N z3D#kKT%<{V4K(aXjsLI;xofbP%cQ(0{P#UU@g6+Umn)&Jo4)DQ<}Vh}W%0H1b%YP| zR8xDNU|w+%Z=Ew34t3Z-A+`frQ{I&`5G(NGziKNb2IWVGCl%%xXqQj-e`=fgU$x!o zSK`qgDw~<3hQ^qyc6o~U{bcppG0{I%ZW4B0Wl0Pb;pN~I)O-&7gFB9wgkR(pfNY=P zyJfyr2^bjrshxfn&HP6@A36}qCAb`sEwDlZ(Gqf&`j%;%eZ{DdMvPVsC-8apwrtCF zs`~M9^#a3x(WPoCAL@b=9Q2(7^y3=YDy|1v zued6j7l!t5g?9u`rZJYtw4sLEg68t{tNrnVir974;H!-K?t2N`w#>XgN5zNH)oI7j ztM;p7m$Hup!OfV6u|`fy(q-3diqGPc26$rw#yYH%gHR_C#XzpA!VEjaY|1zca*W<= zVe1DM+1Q<14DVkMufzh+$=B2GhmeG_DyfsO`O>vmRMvWm@w_4!-b6!E?iEI1yKrm9 z<5UlOl_NEhs4<&0vDIefx}>PXFl)}%%N7feYp_{^&mKbjeP3nh%xUYp1tHIKhhM(^ z{!#orpYO0XdX}fi4A(~Y)zeeI&3r&3B~;)DI*Ek> z{4Ew@R8bWyh*)>$rAM%a&8|i?KKp-cyP7!saFV3eoe33xOs$h~rxjQ9K(-givCIq; zBwZo_Egw^^P3cY7`c|&{jPvq-jPU+3Y_L0K;Lic`YUFd)vGqb7eA_zn!G)WxAA8yA z)TI{mS)%Me{p9nQf@-i6S%{s5yfxWVyGp%sl3)>s%b_RyDImObwXGF!j)|+oOy6To zX37v(6<)zX1l>zm99aIN6_X1bU;>x&tjN>Rc-YU!5(YDk=f*L_wU-Wjv3i5V^)@3p z^c7tVDl6iayklp;#fIY%l;SHSMguB9vi|Wb22^6k!zn^t1^$<9<=a)JC~lYJ!Jo@A zr4r)}(X%}V>Ci;Oj(6sx4(NgnBo<%2%|^g z{l{$?fUeeXpRF7rLd%7@Yk>AZ|6O$Er_X1S&v*a#uFo54$z4i|bBy~gb|sQrC+H2I zKzqtnJX2?i2Zj*Ow}X2Z(?{2X9R=*vrxu2LvzIqc+P2Hlcjd`r=;>dy#^V*)Cp&IG zy)+K^_<{03&b55#m9DA=gve*)90xjWKWcJF)^p z*~x;+=DcYfacl>@VI=zjU7$3^=;j-vksN%V^BivdFVaXjYji1w>TwmmX!up>Xe)@C z&NvA=YN*Yu4qm~d%yu?^k39I4>0+{ThT4+NGUSIUW)X)uVb(YYrIs9{0*G7x)}6KH z-}SLUZ=6C{yZGsmJ*m|{#vE*nq5J#AT6|c3=}Hy3wEI(~QBPu1#IQg5M2=j4i>LgD z)!*IuEPG;e#1(!W5`i)rMb%xK{ZxlGZRVfgLI$kQ7MGl5I8?E6VD9vo7}O+4>0b%M z1d2CCV^&H>wTR`Q3$ORHn5ws6xOq*3R-hKJw}y+-ZBHYP@2wvBCO`vqklFN*1h|kH zr3h&q`P6pi{7!7x%o=AJ6&UgLc>_&fR0k}rM}{vPwk?#k@y~p`T#@2g49%>CAD?w$ zI(oqxHG-)&`%V8kB?|cC?u)(gJA$QLi|eAM4|%O9Jw#|z(KEi%E4yH8O)aEWCR~I-seBY#B3tQ1|Dle zi!~8j^j>+D{g7Umles)kXwhR3YkiyqfkP+LrhZn)_+}gX9}xI1-%d^C41JUa4|MQ& zwiUcm#oSh>911lZ`n`gdw|LL?2r0$a(%H+BC<@{Zr!xN{aFm z;amlr|3eMo$bV4&l6Y2w38>sthycU=AHb#6L{bnQBR_>mCAT1(MNqo*w4O6Nacx9S z5oI?r?b#Gl#4Q{6U%Sf1rM zjZReFL!;#~G6FkM*DX_A1=${mcMKhm3?8uuyRGb1bSB0X^-_OCwH8ZaOWKI!G6v^R zI{QKL`P2lg%Fz1zDMui0=MubiD0{g#(CZ$50A_7o$z}foxVLA1$kIRmcC|%3To7NP zks)s3KwQwu+_L6+mn`-N1U7WXL^|W0s=Da`*~3)WtPZL&k|n-OdTw<8h7Bg>0*Jy4 zoP=se$X@fT!htzS-3LFfHXWM-K+nMQP>f&8IeQhY_p@mB7rttCLqB;l+1&lcJ|pdpb|OvAQs71%wb5$D z8!xZYY7(i&GcbzdhmHRuP3O(!YQy>=eZHX~^_+O7mTLa_#{WvvlfyN&zIdR=sA0Eh z+WpSpaUy-CBl~BnH?{hE7w6E8?${JjthvZ( zLqwz=N&^mLm4%Mh(cesj!=Grv_A!PjVRBs!3luT*ebi6q?_27RX004M;v3KNmKaEq z{;MfeAnI^l#hdwi9VTb_Zwd(`f%VnLApYWIE`Ifb<_f=$dg}$T5R2frchj4N<4vb& zA=J{z4AReo^u-+eM$YyY-5?x zvDAx~j%@^0E-z%RuR?+S^oe$Y-Lr~jZJsu4PN}?EthyX6gBNwIhI=AXHV*pG%ns>F z8VV1SkCmAMon4q?bmO`_UN3OJr9v}*$u-I-a%qdA(DGmshFs3MPM~J|RcUZdhRffw zmFKf@eKV@mo$Kr-`4W}oT=_5C^KMMr)Yq8mJ)zNd@5lH@slcD2KUtudx4*TJf`@*! z6t;NSy&Ztn|95kK$9a{C{;y>Zrye(RYHv2|oBG{feN24IZ-><=UCvnpCChk@^VyMtxMb zD^^Fis}xrGzB{xm1XS!}-ZbI*ENBA$xL7w$GLti!XVohYJ@>~`a%U#=&*F$Dl3s;N zhV{i2zt!Y*ca7C|W4OiSotC8leZ+!R<#%nqE8WGKgq7n;vxj^OOQi2?H25wWU~Tt< z;Ldr{iU1MU|H7@9xOQYTYb_W?6FHXT?k5tM%R(5=8`dNhCB`qQgI!D_5~yHqyO{kq z%@-b4pblF9y+c})ZA>P>F{m>dAZBYoab!UxjK11!5IcO9KG)~1={ACsXKOYWsxHY| zd;?QQSSKO;Q_kub*V-dXTprM7P&>l{EC1b+z@x=hLZ;H3Ve_NCnsHNQn_)pL8kQLi zwmT>!pJhL|uDZD4fo*Cb%!w*79&X_4 zY&Q|r5usBZeGKvx&yN5Q#WR$k)dh83?D zV?Bq6pm)y~ONLsh$+9g_pkVBN-25q;oi<{#0?)b(j_?#Kf2OJ7e4(6UG7Hr_L`2gZ z{OfH+s}TM0h7z^5n|N zcFbOP$br~`gldH-b06Q5otA!LMmTC>^?a;om94zBgHG!*vAC3<+T4Lj00Zt2MWB;n zyA7Zd5lQ(CNUtcV0Y^<9F6}Q_@Y)W%Smpi?FK=IVujg;up3T`f%l?OLQ$!gonP{JQ zASKet+EB_L<^w>imX9o^-JZb<5rM_H<8m-eLP*(!t61KQ-bMEEqjufT&^E%{m!?^S z%3zKYZSZ%Zsac*lZ>tV_ZANNeygL=ph@}yl5#L`{lI;S`$r*J;35i!XDFZ{sd=8`J z9I3qSbvSkb=Z62VZA=L|e_^vg!EKJKA+HH=A$pK{9fwP{C@f|mw`4!kO<^)F2UwWe z9L+tu;VKbV-0}n8IB=JVh@WR&xV~TOu5KZnT*d#3(Zs+-!(MT0DzmlbOI>BQJi0Bn zi9a)0k`CoAQ0Fc0ki+?uU?;Q(^e9BVb6MQT#Pw-eQ}(9Os6k+^x6Za~N3adXmRN_V109JO$_xku+eY#SiS+d+IPoJmH=I&`(cI~<7? zk2d%N_%sXs)FNeqbV_aU47H7D)>t1OF==+FsED6iKAZ*H1v#cw<#g~ZC%L)&(rr*B z>Uw^Y4oQsw8*N(mtF2NU)@D77GO%--mH>C>Y}=yHR#?#?gR=yOG%80GmQC2W%1IcG zo4mdB#LgKaC4+!>PQ(t&XTNre`y@{^TNW}w(d8C=3un}6-lO9I%TOgw3OMRl>}zFn z$FrVI>IsJ&lNOQ9Jd+2TCxs`%mV(-)DV^<~Y|Og-PScz0tPaRa>b;BQGkQjRjWNv{fbGgsp=N@8^9R`}1*veKnVewSqoA84I3|?J0bp*Mq6;-M zR4D_E{qQy5z*Uvid>CaM?*_P4X*wo&M6?h@|K<;Y9)tlnpMb1hTx_t|sXTOd26MW= zXPwO98!U&DG0wO=2oTL&gY27*6-QY!;`1sSO89DUIQLxuKQL`+aJ@3(L_WCLd}w%C zQzOg;tw?m(LAfBb*I_wplwqNz@D4k)&Q?Dze2vrU-aCCV!KHRwdOJ!|tNPq^5ZhcJ~rUdfO()l1J`|9bP{zoHSkZysfvSV#BrvkETMl?@9b@fy5N=bYjazu*SyM-Y#wQ z?YMdZ{m%bK)?EeF6>aOHo`M7?xJwc&xCVC(9)i2OyH6lUaJS$D3+@gRcXuZ44#Az1 zwe~*u-m3dB`s;WaRinQCx4%8Arv~{mc7*F51}ALjS+}>cdj7|4gPi;cxBs~4wl(y{fJeutT*hlJ0#F zkOSlu=o~Z@gq5ND!q3X2uiHs4biQ&y;ig#F4 zZrif8FbDtDOc7d-P5^lKOqO1fUk7kg{bj4&&n{an$H1v*@!G%)s)r%Gloh?M2%az9 zoZ6f%YA?@fk37Nf^~77<2L&c$a0S6E3edZq$u6wuxcTY7``By$^ULcuvMSk4e^2B$ zP3}{9#`}6n^JXj`n%b-VTnqK&#-_iWuxp=%J7SrOMdxzWn%i*)RAP`NHG0`>%i^fP z4(>9JaGk4cD|^xzo_xNz08$bh1&6eH9|a^|!P?c-MVFL9!9XZkdH5lX7NT}}9Fj~b zjR#iuH}dJw^7+_qO5e@}s)MV*{9szlp+Xk(6_*r>*|$0$j&Mtiqh!6;o<*R%rE5`b zqE}WeBx7OXXB~Qt%HL!q>*4<;0uJK6yU$wn*?lkXJC!k03T~NlOJtpE4 z5OyCmqEB5NWF}ev(zXC*gk1!DL}K!sssE;Jx#^*3>{A+Mfge#TKra~of!nQraJ&5v zZpGM5nZUaPcwj~Y>4M?B<*+O%!AkFt_Ra`T#Gq2uI`}J>N$A|awC(DCZhXHXxM<|R zXZC({bb9Wb!XLYUba!Cy@4_wSL$DJ zeVV^OKUr!b5XL5qTL2dR;jJ8PsXq}qQ*ElIEaB=8h8fl`M>{n~B${r2BFeBcF#sGu z(L)~=R%l_Em}c20=}d~B?a|x4e5$NHjyPwmd)O$qb35vvR{PJ@rPOOp*f8IjfTvsP zZ8(mB({OA%K5gV#hH+Fi?26h3*#WnTqj@-*+p;(n*oeY-4T{k(I{06iiV$k#qsnjyRbABDa^{x~E0FZDaMuxwVzl+{;Et zZMXQ^?GzDKW<>A@IZji-#_Q9+C%it@V^Ct04TZ2`erFT-d|@T0>hRHCB1Nd)WIb?9 z$hK>boKVTP$Sf4Jc1Q^hkTkZw{raTY29GYkH_tF_(je8^_T3Mg!8}3IYCG_ zeY8fbK=w|~o-K~8s|?3`?a?&U2C#JCz3EZ`HFl29{{>veuz!F{bxKzduqELo_~jz> zHy**9fkNn|R2y0UBn5BJ+1`B!Kf9-Xls{l@BIB%0(Lx(D2?y~hs}MdPlrTVJxis4o zK;DZW?OOmKO)Sh!{<(?*JIQ3 zRTY_?J5SWbP)1j4)2~5Kr7E%gKU@DlvD>ZxjotcBh=;-4Ldd@V(qtfko4&9Q2Tw<0 zR%E73IvjAblRh$p+)`@|#FIM}r;1d;MrOiw8u6~n;a~1c1)F)LbDwE6-u$T#-#RbV zvjqoZ#vd?zZY@POb9j@}RnejQ|s83&Unu1dh6qElX`kYIGkYG*^fEf+Et`q>${<@R8|b zmw$Rt%qPhx6c+R^=zI;CWi0UXG8N%V{~FB~;jZ@T7VQ3{Z!aVG1ZQ$N@g-4f)?=A> z6MT0y<&?PQNH7&nm)`SyphI@yZ^k1IU?E^M4{kg7UCL3R&p2jlLvB#hlWROOhYoyJ$FU1RtT_5C7IOW zTKT*at;{N(_*&gcR{IzA_SA9V*xs4NcwPY!#1vfGw$Zb+By% zIXx_?uOVcVZlN_Rv-jMom#0uf9N?us?kA~dq(R|{!j}E?=Nss(Tk~6EP#bB+I<^mH z?GB*^%Ug+Z zQ*Y7=XfQ(D5XlPgA{n=B9nEo`*BR;MH%e^`c&uxxj@T2=pb<_vu8V5M%Mqr|YZJrV zc|D_4yf-*Vu?PMLU>*>vc&b70A>-Er`hB6Wsg5h^AS?`J{ZwT~Q2T*(p0iTH2yX$u zSkBvEg~R@<`sj<4c$9)1JD8Y)X2fn*q-N0u&US+}-fcyJXv z^)DHtrR)Y4n(2)#yUJLI40XnLfZ)~D4>dIif{0yEvOeFkxU8?f?bMo1lW(vsBVFdCU{-RbHY&_>>F(KPSxxgHJ_sg^Qvbp+(>=>mTGY-`&V>5`xaKX^ybNQAJTrY)l;z^$JV zWAt|JOxDlzo?AVU7hp?NdX#l88~T^-5PJS6$#y>p$JoJ>QBK%S!sa^I4htMV7JP;q13%vduLaJ4`8I(3 zSev2}Azu(jv(wni@%+*=yenHn+kV$p_ySQ8xykb@Whu`&VWS#EM4G(0n)UMVVO|ej za5_0cxQTIW2=<>Z<2DKz!W>%2hWjDUiFSs}PJ@2{3D$Sxw`Rg}_ z07tR3$w;<@4YAMhN%rZ{)I!8)yx|En1QZ1Lt|&HpUW=cw8ZdsKal{6@dtDnM1b}Od zqznFj-OK)I6L1v?jvdELLM8T{C|>l-nth_B-} zo7-?nzB@a(KGd(O{0pof)k4=;JxDR{Tq^4FvCaB#*Cf?a(wh;8xis)emmbc1Fy9DnXrr}&oqEW8tuRj4z4C0ppFaAas* zr||W9Oy4uxW7q4_y{Le`dV!f%KQ-wm3h>=}8FOHj zQ@-}fv(A(ql6DDQ8D2^6IL5SCIO~yJ2D5h=tf z`91PSF7??`Kvok75{Q^PGEqr)w<@dGQvAc{mVf#<0F$n&W^}JuOe%QjLK8escJjJ8?-{F8A)kb8g_8R|Z&ODqB0 zm1jwCOiOXw##su`{q4fy`O%@Sh+=Z2vGK9cdgNtaY%hMoy`_o&%?nd!$WQ2g_B_@? za_=3ZP&StQo{=3Sw}`JQ%PKMJr%!utGVk$63vBW@TYEF#v!s%BlqxV6d|A1mBdRIj zFg;cVp*cs92oeH!NOo!qCpDv=xDJoC_n*L(P7yLDiCgm?(oHV3!u@^> z1Cc(1v3U|x&bmCGMm3`=RB;i+(){w6%>=6#N5@h7z^Ulm@HDd`_iq%V=!6r(l_{+Y zzAj&t;YZu{}~TWYgL>0*W>|4wgJhK{M_lgby}V?1J(kKM{BaWz{NR1vH)9c4W*&zNYb>FXq2 z)Rvw;o3-NXm%AP#-q8%DkQ@G0Es@3>OiX2fGv0LWc1x&4EZp~TWI_Q-@niy8pC-F; zP!qWW4ZKf+5}va=d;gxW+(TUDZk?X0jG$T6$&he3A_9=llyUAAxo7TI95V}daYbq3Z-rq~>;iV#h|S^w+dl8-EiTPolrL!Yq&z+(6&?zY2w63vXCj zel(TaXCo(ca3R`rW^6CF`bxfr)QL*;92B$bt^cFp-1OU9Tw)^Jq_xOuVXL_qaKx0X%p*)m=zy|~*mOY&uo8wsrdBFjuL zPoQP_No!`OgpW5~cbVrsTIgH&*?5^Khb9U~%H z+}^pEr)Pqq0_zz+9>wC6;_->LFHk$@{LQ>`MyjArTf8k7o-H-+hw~${IXgY`T`%1P zT$PVoxQR#+Ucc*IfoSJ6CQ+J|zcYdV5W$E-G&9{4)gmBkI5|v0&1W4+II+!30ljXU zw@9}`;Kl5kLWi?6P?~8VOM+xB{GTJxc z`~D@i@A!AZIxjmMv2{9TY!4#X>Fvcr#SDHoD)PTw zIkf?%mTWY;=^Tw2tz!RA?Mvz(Wk)%fCw4~kctD6L*|yqV839Fr-J znf*@14GOz61qS)%E)hP><{!k3@^b}>C&>h+MbR<$nKC7{_G$Aot5#~JvCwS|HV!m5 zVA=>mneaFnrd!qO+>_2ZLvcu#UlelvqGRMTI!0zRvVG62UPbGq`m!N2G>Qo|G;5;fq}2vX~{G%3GDFj1WQ zycS`3qrpz5n!Yk+WnBi7C3cfxLs^FMtzbpLP&nv1 z1g{^kGWMJE6SrV@P}R>eP6g)KWZ?BTwVtsZiSSzMP3d%cvY$hFS+CbMSFQbbO(%)V zV(du8HMhW%v_2lM(3*P2;U7$;@Z+nxY>)7K!rTsbWW*GACK54nocjHnK?&NHnYHXr z;BOFQ@AJ{>nG~fVK9;{MCk5%G-G1Q>w_Z0jS7%)7z`)u()Wx|%cCHBaM4ss`59@Nc zW!7U*i)+}&kvdV|LXU>TB~w*I9VU1qSdrx9_AohSX?X!RFn4vP77&dg5%FSTH6OM9 zzJ6M@>#F8pY^>~o-fZ3nm!Z?-p_Ao)A)xC}>e`#vzd>`(vQXEO^Xp7t>WzV@OlU2Ds)U{ZddoiWes2Sfgdsf0_<`TZd=470Qc+Go}W?pLfAyx5m zxrD8-DARRvv03{a5}%m3jA<(~Y15*-2jK$F&?NPJ26gIHN#NveSaBu08y$qlUiLqi zf3e)3h^@QIKNDx>eXgI%?QDwagh|l(`ybnj{A!-_d;8_LD{x`<{Jfb`cwWVYwYxj&dNy%yM3bTvS;##x;9Y%|PQ4KLm3 z(Z3%cp|P)rG_BR`_r7N}oU5d0BdpNrT!4R8FrhUyuxJBo(R&dB~tzHioy za*$~7^9zcA0*^=FW5xc)Dd#aUWPMb8P5IYZyZZK=Z+at7NhN4#3{Nq_V$CN<$XRf* z@&2bDoz@X(Pam1Ze-HDqAMkWld0StJQTw(6JPmPMGs!#mFMo7NE+}7fMCO(4v5(mI zwYrG3tgk4OGm&y+IL8SF$*Yl~6?2F=Er0amVs3J1QOxfmHTtnLPlRSX1PP#BlN}++ zLpiCAx3jsbpqHJCY$u*Pey%OQ(q~f3z7_2HZ73Tut|mOe{{$Eu5f2S+_DN7zLau1GZJ!2jkx|VWF1H7lONE*; zRrombS-NON^>vo46)y*hMb7129%~m7)&S>~aOuH>f*{O~dpR(quVwa1RKPB+Sg25Z zICA1az@5j%)veBUjDBk{q*JJ=_2QT!`0?cWfzEt^&g2y0$uCdruM+htpc3VmGjiA$ zh5w~vhy8Ia_x_UXwDYj$##z6bnBVg%@wMR7(^l|tYgufY(~aZFh6NBeBd_%iUP&ax zxD==fr*2ntWygf2rdB9qPT~rjOgofeUrh|Jk~o}{StQ8l3;p-IazAaAiZIS`B3f>e z{zM?WG|kGmk}KVIJ(P6Z8p+mEjrXwF@2MUnvqMbN1VmB1cK5PJd4iZwQ4Jq24WBJT zl5l5**>KxT|74J6RUw@Ylx-q9+r}a6P;nRLn)(p;fWRyW)0Ko%*y)?S<@Yly1>^4c zUNNQ3Lu{X#GDck^#3HQ<@uKGF612j#jk5p)grNmgoqHA;z~)~-RpYGRDfOnBg@=dU zK1bb#VLWy+p5xJs{bdllxpJ?7-$sX;=8`?V%o9P^_INYdyb*{0z(Y^m_x(+Z&i8dM zV%bXHJNYj)%&lFzd;TgpexqY2rM0&zx{uU-lz89BYCQ)n+mrZhC^>v84G+pMrt3V< zMFDxG__anVh&QH|IUZCT=k#>$`>N^_&S!x`8&9)h<5EQQG zx?(O_eq@$EZY{EY5$>K|vfkLgUv2+A(o%~k9L$r?@%YEy`s=rMUIV`>9Q1EBT5+Dt z)L%wq?)pks+_f2FX2DAcn1+FaT7+QmGy}~oQIN;qbovBrrGNVqVH^%E)xB^HJMpTX z;b$KSwQT2&1g)RsL@A`*n=$*`TmaFh)qk7n}MM7rLYOe_e zRR-aEN)M)g#3F;~z{J0atD@U!5?`*rs-IU}+x?Y`7v$=oFOD0BS1PQLjj>p{9Z$Ci z)vDX=H-U$EjFXc7o36>YNd}PMRBvC{L_Kb3fKsI}8qKPh-npBXZ5%p#*|L@#-S&*( zj@qjElLfgsSH3>#k}#p0mJqYV2hgYyB`j-v1IIDj7JX> z%1Uns_Sal+>HWtq@959b?VH@>35U){PQRX7R?G>F^@~Tg?%w`c;XYZsU7=xb=-7Qs z6&BBRos;uI7hjTBb=HCT;AdqJ;;5$2##5cp3!BaD_NkkB@IsT-(tG1Bi#214BnO6c z;Np{Nh@zeHnLqXm-Emc_NJ&bnLjGLaodSPyMwOe2ZPY5QHVlMl;I)wA9HMEDR&`H( z92?Qk>4@sIWQl%fOp~$V85-hD}8V6%=U$)_UU0` z_|I1v%9!GJ6GxpYWp!UALRLJb0dRsF8y}`g;i@`Pc1>1xv@|1ef2)Vh^>=>aQ{HW3 zSq@UsSQsa3sZpdne**6Q!MeXC5DZD;n&cDvo{0B*XLa&$j?A8>`Rv^UocacRA7VB9 zJ<9`fo=4h+r9w|nbqPh)0&uanink!5UPgOa@dW=hN$PO_L^*gKQj6g7rEt4uHtAqh z7%@5S;$ArOz`|Qy_~Ev#@~AcJBq4VOWyg?Q3+a8~LjyIyFa-N#Vl ziU!-E!p6EBRUhL2PoG{%gO=+pn?-QcBG^y@TD?G&4HkE2FoHJUybxl${ z4fbH# z2gYS<2K%-~_#b%koMRHuK*bZUpZp$XqS-?TZGX5s2)IQdPQo~9>M?%KvAVWmFx%c` zDdpJ+AO}WemJ>KO4OV1ma*Zy%2#s{D_AjFPIwpG-#@D2>HxW6bA0&Dn^}mO{Dc}8k z;h?&PRn2=RbeeNb-c@#JIml65EcQficj|De0mxX|hHFapZhueJ809emKG8*^3D z58{@3Ns4O1@e`@Kn)&kKeHkBS&{*3T)EP;}(1HsJgI-aE`t1Qo-IX|6G4@CvYLE5U zpn<8Hh0xRcWeP4~ae(P^^;wk+@OQ*VQn)!PWsOew=jwccG{?t>1ghyV zws!==yfgc;%>YxY?@CV^2F9&%pkn%|iknfS1K2pA>=Y{*Sj~`W$un1N7QbIpv7cBr z6PkE(QFdqnm_(S#l1HRK33k%pW%K}Js(CISy9~^6WTX3Zm!=MUbwlP8r9WDNmMaJQ z+_E=1cTu|2+iv~M@-2dN*3=0iq860h9Xu&%YP%sk8}5t$Zzp)tj5DIuy7@ zQV`O!ZR4Ylc`UaaO(|_!wK6*s{-HI9j#z}l=`y7nRwu|H4R@X-qI(`~3Ef6$kULrO zHIFm8kOKiRt>;MIA+95yohaphOG zDxtdwCB&bPX$M>V4Pg4L(Z$uB!ste^jw^8FqC zbDo1vwlLHqS9{GYWx8!eSGCDaiEh|ef!JWC6OMZfY)PuFS$zhH$TQY7xlUJoQ}@@S%+}5G}Psp4d8#4rBPr zqt6XlA>#Y(Q$j&OJfKd_6%9i`V;GqFy%I38rP{2h>R*A8Ep(H>06`}nFsUz}KRR&W zdg)|i895KQur^!0WzDx>9dR#=v=y;{Qa7wX^Nm4L+X{=9S2-5#TDzGz6IhIViBYHy zcoatho9g|=h<+*snL+H3(=J{TYIDNT#ls4;*hw1Gx&-pRU~ID#$gR_vWV$JZZx_(C zhz7QVz5>f|t}em%_}w&ckJHRg-%>&jaIZW!_F~<%4@G(#ocD1>@_BgvLyjC@an3mH zYORk$?MrWbG=1;dcc$Nj|1Zk`_i-m?`KWCk?Z8z#l7!9+xnou;5zNl<*<8%~8TTQ4 z&(2sLEw}(YZ9?!Nr!x*sj(!4|ZnBDT`x`MV{;Qj2<9vV}Kt#s9mc$?3gKxO9`c!>9 znJ^D|E0d%N3EOk|VBM=8Ty9pIqcvo$PlXPiZBR9yvVxZzN`9tM1HHCrpMrjTihKB> z6qd7K2~i{_Sgpen<|5GY#XRWKKxGnjr?9$^&$^{u-M7kMHYi_nTbiba*e$3bO{C8_ z*93}`-Mq8)VA-95J2^2;KOBck?h05+qg2SKYlZM_iBRiumNN74UpQ{KJ=9K> z7Iegvyk*WS<1@awSv)8X<&sC`^~2Whl|J1}lvpgdziCL!RK|BPy{yF)zly4{|IwNY z!6K;?H)&$_)1s#kQRbOCg?2YEvu%UmUlL*jGkB?k7eT3u1jQ`DYcM8QgtiKLDraCHKvm(_x6 zQSatcv;XB8+BZ9eBWukye`PALoW>hBquy!$)rGo|G~Wu~sZJvJ14x<5V;L>8nkb+` zSHT4obwO_MgXi*r5K{LMuN5>)_x*)&~cWe`k_@C#^^@?nt^Y? zMnF(m@P(6yrwV&Xs26q4ekLC$pUs9*370;Dc@Mgxe%dQ&@YKOF*Op6xu&=y-5xNpd zPuykJWSCTaEogq;wamxt5&Qt6$-wlRoxLc-U=A&RJn93pcgo7?lo1$-;h@@6}qNAlBauvbUvVENRFt`-A?>j7)`m=oG0fk(?jy#EZJ?=i=cd}q^V@%6NBeks6iSnF=_?Z+m&M$?YB!DBRXkh zyB>4`9vi`v*0<+H@E!WI+hSOLUKE?Hvth)&1<#bm~Px*Y`9?(=(sIxZ@Pz zo%Hv(PNlE2A{F`jTlh%*Y5dEhfi3AU>~|Qku{I9-2VxB@KG%A&;2K1uj()`32+aJf z9yB@>sKeh7SV%CUi(muW&l*#K#Vo*t zJp`4;TN$*5LB?c?HYmgXuJ5mgGhk?H@ZP7`+z|Uj5H47om%DU!FbfR<&LU5jq17M@ z$hj-SiJxaNsj2SsN!--$z^kj)6)A{_*5}Cs?KkoJLLaWL$ zV1+<_Lc_G2R4aW{1@KrUdM-S)#2E(Hu-7|OvgdqjV?9#{rl0wnfE}*^zk|P#=1C^7 zrLd|{c#IPm8`wn~>AI2w`v&Ye-Ptryau`z&MnRU61%VSt;{4t3uAd+KnKU$NKXxtgpyRyz1TZ$a zzaWWl#jqwQeTV%cxd%#aH?VUk8z0ru;Gz8cM|8Dga# ziQ#w|wPOnxA3rorz-(^bPRvUERpD*}hfzMS1C#z1PWx+WBzJZ^N(mp)+7nkEi?1t` zztz(|n}yxNH-743CF|y9V-!~}er ze8*V8`U5Zy2Z8l|o^c{jyZzg}mK9=kc$A9|u_a(HOCp4oZWV+47HGqZ=(GB*Sr6d% zEf|^vdur=-l542e8*G#ssYc#S#YIYdZ;ZdHKr3+YiseHRwSvGO^B zWT*U@lU`3vuVlVDLh<0IQcz9Azy7sXN{=VwuWN|fxF_WLFE3AMD1Hhht?<>2NGJM) zy}qCA)08k-vbv@(U|59h0{r6_TIS=Gm*tZ$^fI}CTvcyy>ey$h#Q=MDDHP!@ha=SO z_c<#W?VAiiU5!|3TDN|gEMS(8D8fuGd&2qXDxgWe4u8rgF@n3pGwdMVM0O7@jQi0Z z-YP>)WSt>|dS@8lWHPc=?xhwc^Qbge4 z)aE|^UUii>jJcd_L4^;X7%crx$p(=d|4R1*RGR-<269JLG>Tj=GnLXKscoj)AK0@2 znFK$P8rnuj5^{bSHgG7swFLL7dEmrnzLAoFdRee+4PU?pn8Y<)G8hL`aCIy=>;2Um z+}zgl3JX7Q05HOBzh&p!_phyw2gkm}8Z9JDeBL-c8OmeHRpvxD)YO|%o&Xhd%k<=D zEdxh{Z}#Xc;|~gcvHKSl@6*)VkAGYYh7UiLLT_^+~X3A^irfI`ql%Kj<3 z-QCjq@28U@HfLtcPT}VuDtmh>ct4I?*>m4JvA^q$*iUwHn++8&rQ6W+Vf(;kk^)tb z38m@%2S<}H)>O6}VIk+7B&7YuRvoGO!4Un0jd^Q_b>IEjaZr%90h$LMkD>424^lni zoT>v&7Wzftdk*2>3WHIB* zh*E|H#0o?qHhRCUN6?uq;%2Gpwg*b?MCjCfLNzjm(1_K(ToAxHQjpKqcEpHnGLkS% zVgEj<-Z#mIXd^ufKxtv#abGXd&h?KjB$x!?$IF z@&N=X?a4&+=OlOO1zxK#N@u}10n(b`s#bHsYcf$vZoR%_gs|@ffTxRb9P?9aG?phz zfM%ti7p`4){7>QP&-|Ya+Kmcp!ZT;MiH+!liRx#}xD!%vO(R`V-(eilpS;)kVQ$Hi zUmoWwr~-Gk@X?fboG7fd#>WXppbR7Y?%KD9ha74@>!FwI?!EV_AmB`{>N9cif;h=3 z2=aM-d!BfE?R@Pd7eqE_tQoip-t?Cx=(r}YZ<)xwz7+C56Wd((ZyRcI&~%t!~H5{#i?@I-iE0|AD!GjTX-rWKxc<&o$Q4}gXqI5m-6%yJ?; z9V61w%3oz_jq5T{Vvv?vcB3~6byCwp2$Z8gWJv#k;}erz>MWc)s_LTsLIM( zvGGM+%Wn09-X#2EVJ^k?mp0jm?-p=06nNHyQL}faxNY&efrNJ7B0Kh=bF+UwFzy4+ z7}*TJS2u#C7$AKgYuEr%Ln%_nT|o_BNGfF3j6{e4gPX}9eWCNPC#J+Flj7SC&n}_NoZs6O`f3l0X@MaiO0e;Fe_$*LMm@>>PEpb0S?CfS_#Nd0 z4I-Sk0IFLKf*}v>RX@EK#r040lEhAqe=o&8U!8BK6qyM8oS4I?RtpL$fHdpChhafH zQZ>asIYdS=I$}yX|7KLAOCKLrqgkQdGg4pJT~J ziVI-CWDmU)VG-VjFv1D*k}#!p69ptnP@@={fA6~Iw4J6{b;y?EFA6#d924c`{Y?ZY zJBGVL*I=ZKx<#GON*I6+kYu|L_kWpJ29cakI9uIVHLFuvl*5-g=x+Utt##h~!}H*< zqm9oqAkt%uqE3fs6O^2PCzoWaDSE7lR8^DP4M+`;`r1>D$26a=#@#t-%=pVN@?wy1 ztJa{8dIZPLJqFvA|J?nFDe#rfdedk-BFdkT^z_Xq>eBCr%j^9ThJ?)9^PfGh!*i;> z*HY5ODCg&=sp;%b*V;rU!>^o8$O>dt>k#GtxGuq`XQppM^Rd5nuN;}l{s+5=9j=cn{69oYhY#&227%BN z;CJ#rNxnnx4{V#ZOpk^kf_6>Sh!^Stz16c726R4U%eyLYAhr)sU+RvC(+ zTAR_M##Fx=NON&-YyfM;qJmFpFhYw+xBt2>BNXq|+Bjc=%Cuc-J#=`v<_Z^ll1VFQ z9vf!4!G~TcFftxUUv3OHq!H&icJZTshRJBEa^AaOJ25JUJR<{VWF!C91T!m6#r;W7 ziyHa`B6s`U@m`Zc@fPEkYt%{An>5eRil^#C*pUOSnvO|H%x`at0z$piO|UGv!B;Mr z9ocUutP~-%##dJTlZ19F=I{>M$CQ8t`w}Pe6LrYQ#Y~Y9j?ar!AgtW{MdSWPGkmFF z^9i{4W#^hzr_7Y*VN~(>|GKUun+`?=!R#Fg4V+bn@d8+zovAPU2CzD;p^4lktfUe_ zMzvn4RYJdQraS^IpXDTuwLnDQVXaYSv>Tf8+|ryrBKEe6fsl-1$)S!SMoO?4xWKY>-C`D7Aj%lxeiH=>R4 z&jK{-cq0p48>+f}^D`7DZC{?uPq+h+__dQ5ApnC1ZUd|vY4a|PT3Z-gU@zB32`US? zLk=pY@eg+8qV0Be7pDozyV#49^ZFPDQrQ~dbAi7Woxm}II3!Vgh9eU_RZjII zi2L8aPZH@B2bj*+5DSkv+w&c1lWGB;Njz+@X=5$M1I-g@Gc*U?gnyobC0iH=TBa^+ z-Qn@}A=Zd30G4EB_CDM)e$1F;V@$k?q;u|-Z1=pEQcyL%oF24`!6^#HSZ|T~xv>sgp?&NFBFZshs z0rN!tpsmUb###g1UOpZeC-i~qu~G5`(!A7KqIS8g9*_x7WLJu?Q`kM9^ElLWz<(5 zJi+IIc49Nks|3`vZwb))lIO^c zW7)jEWNG0B#>cm~;ZT9_MDYXuD>NKRZE|2cnV_KlPj&m9r1W_HsqW=}Rri*Ag4+=N z&w5&_IfOK$@3;*shoAZzT~hBPycHabuXab| zmk&DbU?25h$>6^J>lLM#$9w*H>5yZCV3*}fkFS~!z6ZHfg@A|*yzK>|!R|EjQvBXh z71?4wK~+c(RiQ|$sL(aF2q2RflFufVF`{9Puq&?eSF22ZtPNEZv4M-+Vu9 z@-{6P$nl`aByG>maC&keL*ba|UFUi(Xf(HfJVrFw@z04kk;umPePtW;_N#l(jB?#j zS^k`BVE=5hT|xYs2RZlVu}oR3M0xc4TQO@tr^4T3u7;by;_!}vmPlrsCCqt$n@Q%JN@88Q8APe5dc;x+gh!bt$V%(CF8T&{5E6%A6G4|5t}v%OET}z4 zcYL6OLr&_dZX=6&!kad~ui+~&{W-%a@!d06npD2vrak3CC1ufzb811!6G{yB$|}D* zVPBZ%{U6#@_(!|rdRzRJiFM-@2!5YF-clS4cd5XW1gCIk4hqw$F?Ixx*67nt!gQ!; zdh0%aMC_^1K!(FWO_N!i_(eHdiuM+`G>$+{{!GNv{jUoN{-DNDv+JS#kRZpss|0nP zb~f;mvmlIIgrcWDAR4~sTj8Mh*z1eN@SQeQ@4uT4hn2fA`?qo41FqDUk-T>MVJ%5- zZ-~K9#Ma8-kJxAP;~>{HV;33v)6x>Cutnu;9uxr}@(5L@#VVR-Qx}@glV=!j3gkh> zEA;>W3NMtUS0`8X_+2>7obkVpftnmr?@DW*@WC$9R(UkcM*Qo^>>N6-7AY6XAbbw% z2YudThPjC&ZXM`m0}u()98)fbW2?!~NTcN5@HO=IUCvDqRRHfV21_MQLLcNIufOj3 z?RS2i?IyoiYN&xNU$KKjN z(}~N;aN{H9NBX1pS0~JpAnWI<>^SWn{8Zbi`Ph0F>DpTT8!V_*=j9h#g>8VJFw2H7mf+iZ!0wq3R`XNNN${L+?PAU3>yPAzz)kY^AD$3(vCddbsJ z>}qA!`TNl%t)jR%G z`iE`X*>19Hvfavy!>qP!OQGUmUc9L2-(buIKASf`QAmeym`31{j3CX>jdQel|;AG z-RQ0hTfr{%`3W33*yJgLi}s%Ga-y@*t(orkAMd~*I^q2TME!A#2-BwfSyGPCK&4$l zJ+NvD3b%iq;U~~mo&2iR!za^GqNmU``oeRvX`&6yZ8K0`u?6%}bVo|sY`HM45HfOv zIazo8|MK0Q{QvkaqUitd-Rb^SKoD*Uo4?8u+?b38e2+Pw+Yu>SCG}WEY=NUlBrbjs^tZ z_&1^=z$-aJ9D=GEG1GBZRs5BF{F&K)LQKnACkVSbWBd@Tw|E(OH@j5ks0SdQ(!`2oX{?28&~SV9^C4Hf<`-R&W(6sOflPcdDnt0cU?=i-yoBMt>_oRBfZk;1ud zmsA$izu_{76k~N)H-&6MomTLZpjcyq(dqBEh6;A)Ap40^r_M{BzmN%p^0WRrC(=m& za|I;G94bW=#1!;PaLt4N%j5n2Tj%qQ@7L)E%|#cyTtol&Rfn6{(@-)HM6I8%3d?U<%F}mXHr2gAbBzi1o$5MLYv^S$skBkc4jLqVfe_(wu z<2J4E&<1Yquib@JQAs7csV#?;-W@~4Ad)%apW~egEaW{i=>;{;mH(q;tN6{;O(UOd9< zbs_=B8-Wvsn*g5zbIppbmp=NsR)X-98bc#G?ra6^^~0@~VpwVCGbYvimzw_{+4aZx zkL+H5ml;=Z@5JvP9a|#hcAkYM(-6$9#qNRBO9=%-35j+N;$&hG1GFRP@-RyIAKK2@XIdfkV z1QIC@Pu3r<;DA5FS?UonB+yP){msxc?bh8JF#rY@F#G}nJ7ACYWtyOj z_yBNk`|T(O%x_Fev7gPdWB~ldS)Qq~~{ZXTDU#ej8-@RS*IMFPK<7&BvNd}Tft)c;g)?LZX6scw|&jKEl_kwiN$iU4n>C)QAs-&oA-U1m22)(aYJ)KV3jrHJajjdG<{n z#@+f;2(O?+JJAQ3D417bk+oeUb_u@~4#P5V=@aWh*D=3TtP0#507&Tr)Zly0orJ#g z$n8U<944#=d|#f@>l6A9>k9t<|6^TG=JORIxyA||;4_S3-y*AkRcM94iC~4frUk+m z3`oWu&uIvL{Ol}&Pj0{v!-`4@cTM&#{E2ll*)mD4=)XDcmIa7tz^lui_m<<&FHc_ z7vl>zAV@S~_R+15{!Km>!5B4FWe(LcPRORVRN_H428zExA_4`&#S1q$A^H!ruP#v& z#gA1>M2_zmgr0)Z_pzR!nY?4V4aO7ummjOf&vR$f4bT47$1~N> z!!tXw%_1lF0{el*!ZtFIZ`wLl9eN&5$tk~-U zZGo=4GyVufKb4>P7&xLfVr#w211u=uucy!0bm!)?Bd&CV4} zv%|{7Gp@9*338jt<6@9botP>j7fU2GEOZg{DI>7(APmD{^Eda+p<0Vkq<8PEdX|eM z5I|8*@7Ta)|H|{})$2ER7uMh1?!Vd_~J-RHrYF#UOj^+oLG8q0MD6P zHd%vwPAn|Q#8>Zwatu3|@}0*rd-IjJDx34WLpEejuuxJw^aQj4!mlb}_tg>UsB6m- z(h4-~JFsrIkNqaAp$J)(O>TIAa4x(epI?hKKrfbv-R`-s)nd&(o6l?(JE$(ta}>3T z1#k08ISkm0 zWvm(XZbHUqi9ndT9wSVXAdYZ;1XDjBBY;c=&2NYo3vXL*_5Hv>J!Di+U8h{dTP*c2 zf)yYu+PZ&vB6m)^CvEMAlzwA%r#KB;Kon{|JbnCq4eVPI z;9t_b@kfz3gQDm^W2|f!8HT&J>utpl8r~W=XfMCp9)kywzm8z9%-F*}m9o`}N5yaD z3P*ESfuXSnB~P(f&gMsB6RfujRTl4nA5C?!H*3Bz1SK7|z%{Xk^ zGt+>8M;zP~xE$<~PRJCuA4>(&+D%_*Ku(#2l2TI;Kc}C7~y`QTE5e*~_QajJ|RU2bV^C;N? zbZY2UW-svxZcP_+9%g(H4Gu#&IBJVcy&G0kHt#~k>j49uu_}QIl63> zg7|GtGxC=y&z?qY`Y;5g_1(9YGhbSut-he+;XSbR&T`XzN*KSd2~FtP^ZDlm;=Ain zq02~WHN&cjer+cS&QK!^{!^L^=d)?l!IZ@g=F@Y@VlVte-*Np-A}^gjfkutDnP^3( z4ubC9=AqTr8a$L{wRMHlzCQ2P9dE4L(|amx3oD-i9v;!*+#RceZCzp0 zn-EJ^os0ST`Atg;?yjt3y8#6!fQ-w%VdM!S(cg<)?h!0E95zjyGGC-tvq@~}_m!4* zMG(#x2)hE8#f{Xl-^!?$BK1vQz{WLtQ=s3&cjKUDN`28;^oY{xba#Pv)Hb!*FcOTz zAFq*BdDZ9!4xl=*l7CcYUCYHq3&0?+Hoc91Xe^JdA%Ub);M_ z#sG|A&Qx293GFW#gy?m#cKtm@(0R#3kPVzKKoe&}5R@bmzmNyo5Uz#Q!Nd5s58jh{ zF%;TWyIE^C>UB6Dz93UU;`}rOFnMz`IHwrV-Dr%bh|LbKQ73K|o}d75!j7m+QC8)x zaHhXCW5p#HvyEu?+UB#T%j+_g`t+jopbY@bCpo6A9@}D>J0}tUWFB*tY)9h>TjhF7 z`18U%@}fh&&l+4Pb{a*Ojgg;vDt#|(}*DGyRx%E9;U!3kn z%0JEKBs@V9pE^|$yAl+i(#VlVP%v#S=ovSn3?AV*rgJ?;q};`$)>nbJ&BLHdSgKcG z3*`B3v&WYv{ug3hjBm5(ZolU~v|p@=f$sk6)1}iT-d&EYWuzS63((PDbPJ&i;O(Tx zB{1&%LnE1~R_HBLo2cWxX_`{7QCcG|MiM8}GL*_j*XDw~1ysFZgEqNJWVd#t;KQ%i zijaaedtF1tb0lzTf4=swJj)LarN^ooJAwKG%!`gQcuj3= z56Elrn!czSmTCGU`8h6%cZE=yVnO>FET<$`^6sNPDKzWHS@ zg0a7$K{73+TNFI^WcCd?J+$xSYZni zO8VbHG!*;X;%N#C7PTW@i1fK?OEjkafAKM)e7YXymu$gd4Z`VAZdAs+SobfIeeWlt z_rLNOmn}LH(KK1jKmG={=(8lV9zEHp?CnVvdKaC`EF&lERSi9xd{dM_vqi%w=4?VB z8~n#*tDT0Oqt7U^93`*H3V(U@MFct7!{3AftB4Whx zLjbqqVz#nuF$?^p7zDrnCatq^c!h_(Z?Xea`sGv>D3dy4W>lH4?AX!Ql6(~DaN81d z8mJ2{xkz(bZXHGcjPJ40U``#1Itou8T7l_T#PLj^<1m?*RVjTH82 zOGIfKZ>6nm__b~fq>FL-V~o08EKkqEpT{IrU@%GI*RIgt$>cLj!VoH@bExf8aA}B~sDwOaHe8%v_PQ0_TndLAg*jj(C)ER?R z;n2fVeuQlGx~$TsYaI)u|2*D{V(jcrFtF5q;8qtvW%TGXP}jI(b+>lvqs+>bgiT1Q zru9D7i^YO@LG0eJE=kj zt%c(iZZPY>oSrTf8h^-#D#CIkoM~AtX5!Aqrq9tAv-@WC!_XiW$`wxq$OEFa_twI;u@*8`BAhUnZr?ds|Lf!kz6!ZeoTlf@Ju2{khF&Uy%d4(flOPEu(cwUa! z5tf%2fTVNA{iB+x>OLnE0PL4Xy$K^wUM($xM;%*5h{Af}9DFDbLndOn(FwZ}A5<43 z-jaucRm@9t*1ABRxGi3g9`a2i*6=1lSm@ASkKeV-Gj99U^6L(99$yEom%nbodF`GB z3`<-usD`-37%*4v+t0xZGNyx?`psYlPzE^SW>DQd&~E{JUcru=RqhJOYunPD1(88j zNq((y%`@6iZJG3JU4hV*Q6Qkv-wHIu#5pgVir6BxZ;xCTr~{c=WbJhH<+gW-^WwnKN?gGplFZO(!?>xL;?C2$gon+opC6Zg?+;S=>=J4^&e?D* z>!?IqHM?L;o`G7~R6pr=619K5QSGvg)fOB2NCrwbV2h1a5k|@Xl8Q$*(Cu!V_4eY~ z67Uye8X=3sPvmDxh16!jq^ds~IlA?fHb!g1kypA$8i%6j`ly`HFh$B2zSbS|!(0Sc zen4>*_-nNhJdE7*BuemLu|V|YO3E4F*eZMTaD%md(Q3*xg!Ox{z>Ll*lT9DwJV+al z&n*KHSpd6gy9D~Tk(nQL4S^;t4CBs8I#E7=iWB?WTDDUilXX`9^;*l|pH5=5oL9)@VHup1xlC zn}G#w&=rYw)Y*x%oE3LVU>0&HM=?xLDF&$>C-HHae%M#5(oz|oXu2dSef^cB+;*4W zDAr=>8t}Nqze83Q7K5yAM-cld26%KW#3XWrFV!D>!_RL!&+N=DB!_(WM^@-W_R?NF z4~h_7KL3`|;5OOQ$bk2CAX8;30tf08kE#2L3!;w+ z`knb)eTR3|+DHKBWdscjMNL9j^o2n|d(`~nkMOA}lR`%uIMYL$MN_cOn!b+w%TbE+>jlSI?O8@q9`hLR>xfKvu5qjgPk6byGOr{ zU_A?G!`YeZMq~>Hnqg3HSZ4Eg>RYq6 z^VjykI7UuQi|m1u`$bN$d`wRl70EYJelCF-E99^e(9PkWxX>oe%~|cNqciin`aT`) z4x3G?fFIv>N^M3-xg`Wtp96UzCDo zc33par4Q?d-RnfrFZoa~^^$8G0ppAje4Lt|sKIbK{%e_syV0a8=SEMq zg8`GG7sB$5!k^7H%l)y-X{Ym9ey+odAb}KNKJfkZDZOrfy7V&D2A*2w0m`3I0c)Bp zc>Hu_ZbBb5t?^4KRb~^zN;EC0>FFS{Nun>6C?c?*HcJzS(gO%~C z&^bH0OJ201=zH9rR#t6;v_RU_zK_xwy>ff#d)Z6mID?dk=5F{!&88|)CpigN=NDcG z%x7)nN?6%cW^xHk^Gn6BR8;$H%XIPnfg#5e3N%0;led%EyECn z%l|iu)SRQ#ckUBw1^rJHLD!4np-pqjzHcfgJGFf%cf{vyb1#VOcKdl#3}@$7GB>Px zw^p=?oN(uBm*jlvjyWPVfA_vvb|f>I{QCj>zG}*sSGc*eH(H+{m$Ridsha%zGYbk7 zFWg5Rb~~qoABNzH3^IPOYxQRlWe7}(bs{bVHNO?So-TdEu>U%swmIVVTDiUuQ*d^R zzVHWXKmE`Wt^5tk$5w0yw;n6Y#-d{eewQF$E=;Ptxyx$t=>;yiv->a^rvQSclWvb0aiAXe+(aB{=f>Kr;F?(nZ^$t{YINMQ;k28^Lh~R9WyXl)Wh*r zWvbS{hED`+smj)%7XCH?dF)ID^DLx<5sX-iFCh5GLv7Q=RCix>Gf=x`Xhs$i&AP^q zQ`Mn@_Er+Dqkkt#pWR!v*!YBSWk%KZPCC2wL7pMKDh{hCp{;KbXwute6DNyv#fr(I zkVJBouf+i=s(=NZB(o)PZ!YewIyT(@H`@>*k>) zwz}yc&Xj;{(S@GV9Y3SV%Fu@Oj)O=BT5?DtRRKv%eZN6m-8oI6#Lyy!e#w67K}jq> z&?+>bRIRo(_xDw-fm&+u7r{tC{Kezu^QB+n_qTi{L?M6Z7QFvLh?R=l;pDWyRVP`Y zce&hSD4G4^O(@y6liL=E-fdggM{qip_051Qc>mH>C^ZEy+nZ|}{1OV#bgDY&$hmd9 zdk72N)fkKqn+^d7p$i!MkVNG~#X|clP1WPORCN_c%@dwaxT6FAXb0@u=>6%x8^9$H z$IaF@Lq>ol8a5^Owy_B_ya;hJgIn^JTh@vWjd^AQga2NenmX!2`ndDi9Ry(UWxwSx zOtpztHBMpjlYlHD@}Oq;Y-R{|Dzl*giDwl=PN;9(xL|f~qb{5{0ZlpUN<_O8F2=K$_1f*M zJd(U+DE+zF+?r9A6`Cw)JiTzfVR(?~=+FnH#N(wZp5R)4m~Oi%i;;|$vt^BzR^8<2 zD!N7TyMT3~&1#A+VUgfBPazoxaarb^SnMm4#NuZf*?LGl{MdRaxX-(4o&E`KYOPiUYF+pcymM(GxdB^caK0Ei} z%0@^(yoUTr+Ioc^6IM7&5|k7|7B^K3_a$bNtVVNW(u_(-)Tw&W@`0#;=*T5MO0Xdf z^4fR0W#5jnqxwKg;S_YI*v5u`{SFA~z~OrYfiNta6(%ZriO#@#Z9kh)jPPWf5Z~sNklJ!p;NSY+B%-Veu)#DRz>PJcjI z>A%sb4HSn2r_bWp=w}WB?`jvCG0#xFpxKK>u-?W?RMyYxdHXnP_Duj5ZA3FYe2_M| zrmLk!PHQ*x7n%K%4%ALKEO9pHJ}Q4n*gN!P!ju< zn+F7edjYGn{=9x+mP+B-8O0Cn9Ea2Ub%`)^>VHLrBi$7@$(f9RX>sTCv%{P|8|^U}aurwXs;wQpi*8ri={@TDBoA%k`k;RHpXh;#CL zNFxE`2tEH}P&)d;$#vHrFA&{keMt;H4GQ2J+_1n9!(kfxV~;Y^|LBvF|D#V*C|Fsd z#ja`0Hc%IczUK*4RxNU3cp_Paw8LB}*ljsmBPnPSTDD0F=W=A%3ejSy=~d?*Q*hkd z3|6zeJ456~|1Oo}UiXfvW4JcD97l#-5=QMtL2x|;-ApHuK&Z)_MEr(o;Q%CC$NY*> z7TZD<&&-3whB9WqAn6S}=dAT8N5Yj0}1l-D5Jab3?xN z*0nv3Bg*$k4v)b9*OZtg(3v4l7i_u&x^dtg%0_rv6bYZBbAG)A##5XqXO76ak%Go-E2!;yDdzOQxQ2okAJ8yc3 z&^vB=uKY-U`MSKdr#qa_ohPn3ytN;^$hL2jYIbB`;`t?{y|BENoTuD5Dn`ShIle};&e zr)9bASqN6EcY8h!TSESm>fMLohe|-+F5*E%TEs3=JPCqR2;9yrNHHfKpWp32(naXw zi}<<95xkscn}I8!;Th3u1(&z}KZc~~Bd61EGMQ<(v1f-~`U}|{%P!#}i&1}1 zh)92SCtg8&8>xrFK%CTo!A!hqi{2w?q{}D^Cj;8C`p(Xdb?R_l>f~N?!>_ z0~aWrA_>HN>`*ZAko>4 zTK(3aZ=;9K-5J;pR^G-l>oO-NoESbu7c#3v&r|x_*Ak~)F`_0#Jp5EVy$b8rqM{fy zuYhVu@&(s()89x<-nZz_I(7xZ+)?{l`!=fsKF2(@I2tsYW?A# zbS=zA2BL-n5_z5G$Z?M8FdR||ZS7{nYZNqpwh}&y8jGC2OqVatmd{5zwY8M&KL>&3 zyIP)Rm_yLsk#E&wiB?V=-IuK6WR&(-tO1z*4)~2y!xH*By*y)1MJpUq+42(b2)*Rj znOsFTecu}X?2Yp%RHmgj)ke-N+64^E$qU7INr?wn*}qz>X@R$)sH##PWY?1!5iZ z8qI(l%U6jb!F(VZiQQUUh?TRgc|P+89NM2a!M~_|r}PV^FnbonEVPFKCW6M7@!Um&7VrUZ+%SI;cJeH7z1Z$_sKJm@v0BL{kkmtV?hMif&RGi#d}5(gjF&>w znR-(t8#YoGerQn_yIaqMUUqINdoiNuwDqk9U)C?rH>+LVcbu{p+G;6THuWbP{NIV-dq$PS2fb6aaZQ& zo$N)9`|JGm1vn>C&@(-Lc|sY**gtKKFTOElVk41}Jwh)HCw7YJv|95Oh4w49)b=VB zM7s^=OWRnmL>85<)Cy^eP0y&fo>O40&Qa*J9Q}wkFMt^Mg;UfZTonOt>JOS(({xg? z?WqBXK$AJ9+DgWa&0B0(@33kG)jKCfiMN+9RT257&2NmvuC4vb#A=%atP);3Y9E4%>>KfE&r!g z3_i8Wj0{n`*lml&{#VO4xvPxd`Sz^nu374UwXy(^c1^g%eyV3)8t(n)q51ER1C-e_gx zQaQekpmR|wBWIccd2$GIl_1NV#4H;P7O|;iaXLP8aakkSFgweb6x3dS?h0r4(QCXA zcTdcjvBm!gxy z#~Rn8r74Pxx}eZ@@RYQ>}F@_V1`ad=^(Jt zqnjtI)xMz1AO|niT12hjVLb(q8i*I{&AzEAVx!}1elj+5uG4ALm=lv_WK0f+@%P`7 zjy(n zTf-3O$+0@Zau*{aD}{e=54%=8jJdqFXBDYN*G>m<{J4a0&80VVHgpD9Y{aIgUScupG0ezg2g zvyvYDJSavo%yD<2Ly*ZaAZ{C}wn9=e{>#inpY`nikurvH*ziYIrFkQN8mjd7olcN; z7p^uAO$yg=wJL^SUWg{l<#hxk;vX4txF-3uF$6LqtXeJ2)6u>y^59VpC0h885q?wD zA1bInFshBybyWkIgzZxv=B*#>hAu5OKF74#hVMN1vg?nBpO|6$!kcWw^PaApAH5Iz z{5sN$@Hwlq`Q_N!OTFu`aBBu}V+#k@&Ac$hN&4v{p3Qb5nud647 zT7|Vy;~N+0oncdYRHp5NrEvI`2l+NMb@@G1`7}TNoWl3w{_r$PqTeJM#|%XDPw3G` z^*6Lxwsh?p_b;~|0~nv3n=gXgW!Iw=O(Fd6GzGmYqh|H{H1iY|njI^LklANrW*?)ze;dW^P@W8%DtF%=|R8j&C+MPXlIbbuL*to zeTQTGe-cdjb5+q(Ls_-r*lxUgD0C`t+D4z6buwF;5vd05K+M)*Yi&d4c5n*GZsA!i zq5_$iZy+Ub1^?9wAP^*l?A`V+@c`!{w^50P69YHr$~HT|wp4OpzN~A!RZ-x^N}*}< z5fp@Gwlh$tnUS{|Gwo=ngNPx(Te4k&onmxGM*<2xYcYZ)7J4bSQ6M@jiVLPzPKD&3 zqME;6H?AER6H9B3Dhk2__&C-?`sI~@|AKYS(4CMWe~mRm4yG&sZkH}f%YQN{kw@}P z8q_HqS5ixr{jk8)a6Rc~9}ifh-+9uGL-%HZKef}sXR@abyA$o$(AXjXd94!a^gNs@ zGtlu`Uxy#Ja=n*qgOj%yJJC-oO>!T_YdSko?I6W284LMi)^Vzwicpy1AYkCj7b-#b zup+JPhdb->Z}cOt6Si^2ERAA_BS>Nv5o(zYaC;B@rmD2=x{oJC##6C!*Y(2Q)tsi= z+hJgu1v~LengxR-@Ehd64LnwR=Izg4rhM#yrHEDTS^LoIkjmfZzaXOz+- zDl2gBv0m_#o6NFlU|OibQ7Gt%QOXcb_2BySN)*S!6FGD*Zz07 znq`lY$v4jdEyzq1^{-8A;;I~lGO{R&4U6XV;;72#OxdnUwlDKJ-x6H#KA<^Po%GSV z%j1#f)0kjAnd^9=q^2I9d|-&RLWvSh4^(8!dMU_0)TG6iH& z!`}6b(HTU}LkTcjEY5Zgn%yD1RK6-siq~f?73?DZw?Ma#chOxnns@QB!FBpW8|<@P z`##FGSCZ-^qSx;>R}5THl_XfF3>; zUmHeW7%){eEa2d)+n%~<+OE7BMZP-`{B_8Y{U}rQRker4P%iy&2bR#5hX}qlr-C1e_XsvLRayWZ8^ia&C-CTauqKN5(9y%a z^1j%`huly4zJ2Ma-QU=HEmSH%T3Z!{b{!`Z68`)TM12fSczZqL0L~1ym`Vj5e9|6j z`iglC7>%W=WQRAF8#!DImB-FRk&iXS9*DI3l&`xDd<&?CF+_Zq>K^^-6u{?Ho2fvy zoA`~kf*mbWeKL0v!&*qiU14reOkrsW{m_PW1o>Eiv&PbdN;^^rDY+_Rhiun@)|;Bi zy{YO%EX%sOVz{niZOnbE7+kz~zlpLj+4DJaSndmAXJ&kSZifOzTED!Pb9kzWNIs;l z;YoB>UdIYc>}ZZvC3WUKf}bOK&9Q7kmsX^vUdKxl*DxxFeTk(y&@y87!7lftO#`?j zarySYXq2gMR2d7tabU^B4%am27gb-p4)Yn=BW%|WL-&0#$QA9S}vTj#t@XRv%3R8$$G^;Oo)EoHRZ=@65r#W zrlVTdTeCk$T}X1O0aksf#<6vBXGVTBl_1jd@0jF^0l;m6$>MaTQF;`?d4!TKuwS=xTT@- zE{Am$h0@7PR4wKf>Sk@;$DZR7CxN%Fj24$>9U*KMa>X(e)3cen*&9vil<@ovC1L+k zo|C(LJ{PrGrAIT8I;2N6%>(>E8O~D5KAmiFESFnKgpao8IkLmZDqT9nkIJ`Mj3S!8 z2C47{=WiU9Zg3ROo9WA(-@2K%jU)c4;=|B}X)8lE{w!2=qCk=GUH`pPVFhy`64}j1t$_R* z9=?I3jG=uTac*%^%z})hyW(PP1aPb=$DC1_T$fky1o8a`pXT&&Xw{rI@1^m)7hp$_ zX&i=z1fGoF2e2o2Qg{-H)$8f=(YQH{^`*iqK#aRTi|-axH)nR(aeBeXU$|H#RU-|X zc;73dE|Xn=0aiK@ZBigws@q>PuFwZn!74+c_lU>E)h6=T8rN@O*z`JlFIU11$L(%O zWc+zEoVb`vc zqq*(JPPkPl@YL5ohO;PF4c~@XfQSgn_~%FbZ;7b)vBF((jTw3V}z4u<(p%gkd!+4@(B0nJtUhp??(iGm^S zu@3nhbhhfpJhRr$ICQ=k7?U0)%8sN?gWIc6B1{#_7H!aMN`Xv4Rd<)-d<3RJVasCQ z1c93|en0JC4{I(HPt(L1ojm1i7*RA#&I*~hM?*o4F@&MqHPymA7oCdQ85_MGZbl9) z_kws&bY*QDUBdfeSUr#Kzo`}Z3$F2IGsS6R7PM^-hgLcZiX4@9WCW(1l(!4evZFVG0WQ*B!K zPcv=u>P@&xAFt~=qEjO5k(Wm=AjcKkJ8S**gynWpXRG3HQpXp#^ta#D;~{!wxg6+H)5-&L0*~|8T|KU-W@r^kXBAsV%B!qtNcrA~b4B#0Yk`N?cj52_5<@E$ z9)`ziFJA#iQ7D&^tthA3ngZQd@q1zR)IjkRX5rKrG9V)y5OHk4^<@Fc?ms%_;&7wM z;huPT+p~)4G89(yZXTmFq?3MUQ7ULj@*#xAhU!`|&dg$aoCPqXVt#1;1mg80yU2aP5WbT?;U_E4zLiZ7a7Su%JO zsfgu=K~za>Y*Ghk)bC;-^2bK75QA$(rZ*4`1)UBbk+oYJD>SqQr!Eg7v2`_^MjYfH zO81TC#Z)5>1!`1A#B6ZOzM2^kaZylugMJJI)-wxfuMh>ZX~UiEfHNvMoxW+RX}$I# z8xUqH{})f>9_Ja*>^Z6t`SR7XgLeLv+*Utz&SMK2-}j5*7kvnp9r0e|d>*<)E8{ zsCr2$?upmXgE=pZTBXNbe*m?vcD*7LXr5%wW1#oSduGcPzM?<56KyN6NJWhPP5yjFyY-uf%PpseV%L%Ha@6nxrKL}W}kh@Vhf!wp< zGc4=`6Fb=y#xpgs?%CySvY&rvi2pi2_pM#)@Hy5^U#gOPEzN6!Clp*+1W(1KrcbhN zvjT|1H?H4Uha(^c<>_Cpm|a{O!CoPsXL0k4h?bitxj&C`OEkH757wqFu?&VuWdIUS z9RnXc1qd8SQepgT%)R>B36?-`fT#qc(MzSM+fy81i z7J(xLw-UWKEZTw$i)y?;baEglz3d9-s6V95X4 zXBtSo_prG7d%k`_Na>Q(p2TK)9nhI(znd?NH?xTtcmGdKZX85_XM&MgNZC~Lz_2jBetSX4G;(*ejQc@jDq8Q# zs9Ya?%G9o7QHZh5JG>_Lm?u%=+)<9-3{uZk(Q97*(vx*qQ+YIFn}c&8ME-4}1YuIfv7X0=d~;HGxG2^HE@3n;=a*;?1D zmoV%117a&II))RnRuK-Fzv`sT30paaQm<+d^2jb#kJW8_Cns`RJ5@+~(ASB2%`0Wc z=d!V^@SG+R@2rRCDaxJ4&N&hRpx2QzuYU)2)A}t%wv$6Z|0cWvs9z;!)Sz6#Ng)?zp)tl8A&42 zndG9M^p2ZLB<7Zdl(KXA?CUXh`Zf(6=kH?Y(Tm#KIk>T>*L>~26(&S$OS!Q^164Rr z0B~*?Cm!M;qdL%dl%WMOOvcQ$Y>cM89i1Qb8XSFk9=;kaSxgePHd!d}4LhS*?uA97 zYuuv7NW|1t_KIevT-cRiBwVg2#WTr;FztF={?y;es@VK{DH*MU|- zHq%#vE9b3_(vnVK=4|)kpPUm_c$r-tDTCm8rX&~%EsZLi`(3o`*NU&0F1^+euU*=1 zGRFIPQx( zj5&s{D7)BDuoLx2YaCueG(Q|!{3l>|+y4_VLZyT4f-epjQnGhYC`{o!mIGrHf3k)- z+~8+|suC-a7;y43mDotmij`VX6R?7S{246Sa^})WEf5{T9Jm}G5u~$A{sF`kio%No|e!~CaT`pc=|vHpRI zHbKNz7(?2H}|Sa^PkUC^#8IePk=%Kwmk~2{HM+kfc`m7;h<5kj5TespphoE4JnjFBYgpQ zTi47=b2n1BpzNRX?HzA<-X>PNr^f`w7sADE!Z*sufs~9{2KN&(XV@ zD@G^7?C5`98>UrzZuCgT_Sb8S*A>Fv=vQ9s2ltl~goVreSwY9u@c+&yXFBRp4<%A?im#N-eW{e9|u#P?R(;cVv)+Tq%a`}e)(#ayO`hu>ZQVH7jJ zZjRkAMhV=n4D*}T-qGc4bG~nDy3#(MPImWRat7D?KGGbnn#i9}KoF^2Oe%SS1#{A6EY%SmK#q#q;U*OfnJ86FK!o2B)&;)&|%2EnysH?CEaJCgXz)f|Hn zCDhk^@_7Fe41{$)Hl7gRXoXr=*VZ4oThLyHMu;tCbkJO_FOM6Xz1gjOFIozll!wAC zJLQ3wwSh*UiAN6QNVg;IF6KoW7DJSQJH10KZ3Tz@HEm5#%^Ji6%S20 z4X`I??=g>PelKWCa+O8+HJdI6X6RIKtW{9yy4#JDj5_8`YSY40ZT;@=(8$h9o9!$f z33}nXE!GSna304trskLSHfYP^-t@@@zD|L6XM41J{mJ(5ktxsr#3J3m=5b(ntjuT- z?)-O^DsvE%=P%#8)tJYrv02m6S-XF=R!2NRTp`ockG$(Tgyok>YfL^@G1wULl%sio z*pRcz(yU=5X;i*qGGL-g`6H{Lfqe!Qy5l$JbWeh1T<`a;UeiQ(`+@sL9koisPwnsR zaW}T1mj{<9>F>`2SKo`%*?CmkTB#sxFdw4#FvHc?R*uTt^yi9qR4&R$}`F*qDn?z5h`j>9eC(Uw|lci4i9mvBPw0uiwK0av!!G zsBqc^BbHXSqpvR&*9v*X$6qfJ-%FAvCnrMt`CE}Wz_~1lHXy+jsW>B{h2U1$*60%N zno+;WXU=@n?EQtGRcI!{Vu*D1?>pO@*v?jmBHoy9h&}s(aEbb#I@Y^Uc(q4!k zP^6^i+&*r$P!Wf8n^w+TcPq_7PIV`K?5}80r4mst9Kb0qDjf*C9=0xLu1M>RnUbbs zeRuh7x@I*x1)rzRDP4b;;ip3i2l?AWiY;Y?Cma6U*Os%hhd`(DM-k4TZaZjKTF==r zjWckA=DoiSu4X50cH7OH3e?VZEQt`XUfwp<+>rw}JBcAI+wix4bs=AQz{)LG%VhA# zmb)@?b2TKmeK5fFphW5N>IX_>8UMGUkWWgt{6|p;tRfS?6a}T@OHtbY4@L2fpJ@1h zD@q*km!hyVvelc>NAVWJ<6}emvY?a*@nY4wbcjjuO<%HB1?3MgTSLBkzuS}xPmMeM zH$}na{!$d%|E?&W|4UK!xc{f3NQG4Ll|^)gJxZ7VGWz!jg~Dd#X?^!Ne}Hglf4rRkBqz18Lc`iG#(-T@MevjQmYnh*BIS zVEwF@K-L!UX*C|zR0V2Ztt9Y%0q>Bx(Wwrza<#zt-$myAf18WQ*CnU+6_+Kan@JU~ zauV&YWXJE6p%=;^W?J%Chmb&-6NH*gb?K)Hm#MVB^e$KQ)E)YJNR(lUbI>Oz;y+e| zM+szt(u$C)nrx=9PK-(zrBU~WdA*G}gHlg^a6mTakA}cOXVug^MP7}RoR@~JXG#Rt zEj3j4_uzy10E?wkZu<)S@|-&e{AH}?3WU9J?SfDFyFaKnv@ zIV4Y&O~{>z%nDJDNI?J%=~oiRnF)d{omLbmmA;r(`Ps(I*5>^Au^=b}HW~`s&QH`v z<6i4eFkIhx(KCr$QPuD`D&PA}l`p3Wh{+HE!eDhwN3^)Ipe3-wb*-XCBmFeDBTc1!En z@&RlW0$hMZ3(!YU^VOVNh}GNT)e6NU(gQ&vwzRMnz4_@TVxCPsr82@&`n|~72xe>$ zMmHy$hqx>0)}jK{|6+);F%YiVv!qHi(x?f5rKgcd1@|xuV)K6 zVb75LTc>z!Nxu&IUoPmx%>p~lckjUQ_Y>exRrp~3*sT_BXy_EwkdI#2d#5klNJ&b%I)jXCRKCf5HEzgq&qg0q(>GoR?3%>AZ zLqiJ*Y@KFB->S|IE@cbF(RGF;u~M#4ky5p z>`Bli2Wem^V!8zQQR9Qq(f3UPOU*)(^tmHf{nEah)~BM$_fh0-{KJ$L9Gm2FM}+fN zqI#;rzDs+gzX+({akSYJ6sOwF9h>X0QxHe0H<*SKY;OBOo=Q%gkd(T@_yEXeY26}d zVr1kCa?SQ!(2tP{YO3{B5Y@UM27s~c(6!>7{cHM#$0*_8aNQ|>ieR#M-cXz=}OZsN8YS+e2a)>7FJ{Cc%vrL*lYm(5GS!)-(Iu{EeJ%28lJ24Wt{;M|jR~ zuhaD2_GhO>8KxN{aAlCWHzC%>H{r>#tQkgA{G~*=$z1+>53C-Em?3^Gq!z_4N z^e#l7)G#fWS9UA2JI!g8v@z^#U5A^!LCs&br6lm86eC1_+>k!72=oJzRY-c2WT6Fc zGhs=i-q-GXXaAX!)2s=h>dxmi7~pWh;*4PzuL{tD*DPGkwc`$#z1ggv^hG`J)!KX$ zC@!z{<~E4x{`Og_oXTzH?(H zceYn!rUSj`n~6*T|IFE0aipsiDBO6!VI5D8PoLv%(RsikF06*&t8qau(X;w#+;O17&1#HiVX|h9?KFF*K#n8 znFSBpe=wyZENaqQWCE%mv-*b?iT2y>%XJ~c&2A$7II|fpvdZ_&6wb)R`Udf89tpJK zr5|+>o3}{#E1VU*espmy6>u4P>kV3K_I35usSryJvqqcr433Y%SBzrF3(HD|JNWyF z>*XvH^PZj&uYQ~R*KYQguh|5fshizNSYKy=rSw%cvY$uK;;RhC!`u@ygYsL;=S(pu zO#g~W#ditpcx*lG4+xV^|LUe?!L;6N(_L#$BGlF)x1E67(F!hAD>xj$5jTf*%)raw zp`oW7g94VHR-)02bj^8OW!paN`D4;Q8ns9NHvx?PxVw)Qv8s-qcntV=%=3Yi^|}9W ziU!huI0e?sC0h&k zmg~@&tmi2@F1R58SGP zbJ85tn0`QZ`P8J$i|bo{)3z0y+!NUMUZH$79vJM;YH- zjQ8WY2RV-qe5;kOGoplF*cR4vtJSYFI*IvxlcV8aZ%O(qymIQ>oOPq-Qb;eOk*=@t zHM8!cSZPwtX`gp#2-F)95>ms5+sz(Nz_jZ8GFoK=YBYsLI~#lZWiOqjL%Ce;gO=Lf!On6xm&#Xo1=-TH2X+AG zS2&>7_CKD&5E1ln9?#NnH5@nbKR~4l(xN7e9R~crK;`gm|IOmRfl3hjq>Z!NkUH~) znD#a6)1&k4+D$2KciRvk`|qsPZMPy@3HuSH=MTj)^Hf}QD&7i zKgM}v6en9E-PlCOXXmp{=oFPgQf}!{{XlavT!i9y22sKidiDBmo+ z;+iGf=eUo__d7@Ff9@)SROjph^ye(?rHC>?Xz3|-F%~9%MR$^?RU{<{|2QO1+n^9e zdy~Pej_#NL>#kDF`bfIwon(EW#aHW3nhP3Qis43hawz)wbrNSmz13N4`{6!(^bPx; zykTPt`~QPFnR_E^^uPvoor<`cU5@>GjV7t3_Ojt>j1}@)_EJ4c#KOEZldt4;`p%2L zEfQM+gzXW4uZHv$v$J9B!uNW#Rb`w3$sz(@$$xX!`t#J8(%U>r1v<2e@Fno9=vDbQ z813QEz2Dg$9z6Io=5cZM%()vA%#o}(d?i@m2ZsK?ScL|8NXP;kr>BKo(^}D9`4B4b zvde^+H+b0GL;~LezABm-^2jB6DZuDPA%^tAIQ>j`Gfl4I|7I15UG&Ap`p)p&{zx>g z@lLzM-d?P=#dtG`c9%MEP}sv19=>V8BAd3r`+gSbI$zhWrmRiIZhzqr)+&uNXo;ZDj9x{CkD)a>a>YeH~fgwqT6TCVvM}MXp$cwkYJaZcDSb zM~f||GrzbkL1yc3R975`WvL7J=uXER8D)Vozh84)eR~2VgQrC7b~y*JAikdbMT*qg2LvC!59_~D=KJk zvLs{zwVF{TJn$2K5ClACui9YDRrFdaNUX6P{kmj)Yq`KED+Qse< z+7bh776X3XKn!-p-M}<_MaF1iD4h9D36Wzpa_SNA2QX1^QAbXa-j;9tfr&1cyFmAM zxRDDV1D#tXOK>PiQa}}CP>rX#E*{5aj`sKHv;-R)vWl{QhJxYtKwDhal97s4%j|nV zFIX45S;{4lCXb~{LzIp^U5Kfk#u67&h$K(ERk@s>v+R)WzA1CsCh{?txsAEu)rX|r z<>S{)0GaDMIQaeTd!;`VZG3=M<&{_8)@q5MMC#t#DHN00R+zv83{4gxDi9X)4Y902 z9Pw@ghoWEt0}umN!TGgK2zHmfwu{>eB3@<)w}!C+wT;bI%zQL_4PLwp`ciXDjJ`vU^%y z4#G|s6CiSZPulIDm-DEQcHySD#)yu{!op_@e_N1jyN329cXOA}42+~Eqj+JpHO(LD z`VyT?svvN5{lxSN*vV*NU3$NzIQnN~MlGB?`Q@+f_MhYKPKxO1fZj)N%wc1sv+IcP zS)nn|tIBnxdFmV)2(0^6`e!UF=hPqau2|3p0j=jFzhqXM!fq&LW(_-DO5)?ll^aG) zsze3smfQNQ;rL8Q+4y!Nvvn5V@5Mnjrf+hLM}r*!C=>0=!Ul)Ff`uo<0edo9lh3so z65K5x*5)qnLFO6OwGG+%l9sy?J3$wWjsA~hFh$X6;ygH6uHvQ$6mV*MJjPTc+uQ$DEgVYIgK-$`grM3J$lppKVtYUpaY@biE4POh5c5kOI1)KJ6%h@$vbbRTbT#G z|8z5(t6KsgCS-f-3~AaS6Wq<0@z|EeG@>Q=1L>$?Vrpeq;00nm5B1m!y|kf@M~EJa z(cA^}OiiZQs4`f^tZF;K;zp^j$$cjoUaivabUQ!x-MU6M8^KD`RBZ8Dh*8_1>>0oH zGG}hmh1-GQ|M+R$PyKf%5HdP{oP zfCWoqZ7BO>o!r~#2<_=Q45Cc$Xkrh6jZdf4WqYBRQ}rHdW>Q%{$s7v3UPxs;IBz<5=drT zw&<7yudYg?U_DE0mU`!KpX7Qj$3j&-Ma5b3zP`UH z=g?F~8~8eV9pd{8qM&>UIT~-WEGcOqXrPqLM=mP_loSt-f(A6}Yj6SIOJ^u@ggv-! z+Zg51`D4Jwf@aZrjM+~wDH;aAlkUtUPzq<4_tKfgg0jmyV+<#fjET1*= z3#a4BWu>@^ghGBpvH+H|?o<^y$AAA;p!0o%iw?XDQI(5lw15ovQLf4JiOf41GnPggw{Hy6B23l5$?1lPA@uUrlkoSh4>D`kPA4Ppq} z#&z+$K*5Tvi{o5(b6Fbxd(}Y=YM}YJ6Qo-WjhR?K_G?A4g6HXApd-(vXENKn>rn#N zOA=-_X5=sP;kU#~ADAG2bM+u@MBf8@n~ko6Zk{u>XYXT3nBOSa#dWtklSI>6bF&wC+?pq@R0n+Y@nx%f)N_aIJ?EOw=fp6= zw@)IH*#HZS%^XoX;kL(&xw0FdQrG?skKlQ&k7FJtzpZrXccXX7IvZ#jk~v$|Dg1KY zFmW$$eIRYt1;F;MY=?jSxKFOvTrncT+M=(l36e;sEZedyw)1jdK=#E(xV4 zs%?))!@YNN6QJo4XD~?WGmPB4+$b%zrO^x1!0{ICiV9nW*(v@(-yGr&(ZS;`Ja#1&)mhu0d&*er;S&Bw97B+;4S#`pP9aA zS280^7hSL#2jv}<7*If!+j^?WByJ-pd%xW>$AUp1D`2)`o+8I#_Z5#IENdQG`QaG{ zyRwTCuw*!07VrYHK^9T!;aGza!zfVsgVnEpNK3lL_p8j=ww;^nJU8kqu zVeiJq#Tgr49&%I>5?EN-dvyg@Bv;Ma@}~jD_lyBRkem^=0U5Z!vyX8W(qV4m3EfG1 zHyfA=fT~FN7NNx6&B2F{Lm_%FXjbC<@P48><;!1FAc&Q80!&&Ul1mCdT>NW2UN>S{ zGe91`$k1W=3-h;Gve}$2F;s1DBT6VlTuLN>)`fUf+}_sCV;Wk>uw|S0?TDdzEvsRs zu|5a3re@L$32c`LvvECBpr)smlJc! z;I-M1b=YX^QBeD|w)0OU&sPXNgynPLa8wA4X>j~93wzh|=ML(31N9DXrGqUZwU3gQ z`y&eT1H!WasN$)Y>gBfHJ00|<`y`9M9R51VkBn`%JuRg=2)BaPliVHXnol^6%sC0U zW~H!oQhQvlt{Y%9=Ui$xFk5O~=}ShqWClz%@ILbv>DbCJ2ff|^LV`fZ#U_vPOyv){kG@0#n-cpg*(LQO#A+ta1Dpi4t{W6cpP)+)(`BXN~YlR*K&0e;P zlt|r1c#)G0N<9?${I%{r`iK!cvb5Vv45jKrnP`BPtWiDR>L%GoteJgQmba$dklLbq zLWvtChO~$D)f4SoX|GLXh7IXhJ;3o=W0dB`!P)?KGaMkmD1fNGLw*d)QpVks|8_HI zIRpqPj3&Xc{a? z$mGv;&>eKa{2fv01A<%K^bn7p=sO6wfDd+X<((T)@77a3-32-jxJcprn8G^blJv82 ze~e0{{D3?To`n_)^`c@uCrW^D18{S@O=aY;Y&`c}2*|z_oGaSXGq3MmHEN-c*bKNh zJ1jop(iy2@OT|}hPd<+<@%tkv7-o7Tg$={_53TK6xj&9xHo_W$aMgf|LHQ6)BSo@2 z32=X$VL2d}cT7y-(^q4R*a)_qXoNy?;0>VvYFXqX83Be5XKj4}sXOScl(!A(syb3R zRo_}xx6kN!_NY~q6`T%eHOBL~c8f-V*LfH8z<+`Y`M^Z8SX#RvOAPR$EdXdyV)O_4 z0XrMZGmJEY@-oxYo;}3d00btgNeY|4s17wEW1bAFbIJfGKW^-Zj5bf%XIIpqUH(h{ ztk47H%j-wm3IZOprRz(fRDciOBhpy_FVbtc#d|K&?nURzr}XUulJYA~H&r&3H>=qiA)n;Zn;hBTymb7b~=6wax}GZ9xn%fy9zjsz4;!iayhVo!5kJL`g-lv zS|2LGYIp(f9QjEZluUMH_4UZoiT%p_u9#+0WybC3=&RmEk-W_tc~p6z+$oA-eiwpbKuQ)w-0# z8m)zSE!f+Kl>XxZ92+$cpt;#6(c@QoBZ;R$_ryifsIICeIN#3#|@t zG-)v#y@uM;{%gYwx}8*M2uW!XP2dUOve1SVjzAS4f;Ao-)R2?Glh@)c=-T{Y))+uA zb{(ohjNU)?gJrwNzKxy|7HmJK?$Led5_J+0BNXkfXE%XuY1Agt-TZM;6Q(|xb3nG* zYDb=Tvgx?51ck?dqy5R68WPoqYIvHaeQf^i-0tP&bG4*am|nt1=};__n9A;%T<7y} zpt|!6*Fbu+CE|4>7`j+W zy$HDhlwt>1;-E^NscT;ae({ePda)Rcm9&gfc!3Udl8k%LtcgXNw9T+Cd`;UlA1p>x z@Pf!|Uv4Fj<6SC_y7&2^B!7W*w~0kaBJ_fGdtjFq;541+`@n*FtAYT&eWB%V&$RR9 z`Ua83ybGMiK)GomRCqE`&&In8>Q~Su^=lg6+O&PK-nL&5NTRqQpoSE@`{OaAEyzzN z(t~+@)4WNTd-4@(RqohYc777;L%215$!HnL+;<|JxOsIO>=9Y$vYLV5av&(9%;yPZiZ_EQd}AC8Gi};y-X*K@}d@*og%PuB*{#Hy%RN)$kljrXlTA5sLSj{U6-11yvs1DT2$<-tU3?|E*_VlkV zWX#Df$;#Ajc;~Ntl(ew(=8!@RTro_2^yGOsR808#Y#DYVU!B)PqlyI0r8AN8u{qNX zP1KucN(G*i2m`;p({8%AFP-?c3c%n_qx!}Ym+KKcI@Y?Pp5pp%Bkv#@TH^K7grk=s zj)sv>T02ZDlkMn%|H26*1!s`SiDwT?Ws^{c+;M7GKZdO1lS!-BR{l1J{P$O>)%H3R z$YBNw)L!Ak%+@{fre*$ANY*EuLAX>~eO-)rGkg%pz3ixS{P8AxgMGlW&KXG6ziyk* z_OQklEzF?vx`8Iy`mdhFGGIh5RmNv;m|7eH7RxiD%F&X1SWIja z_nV?&tbn9@CuRQ}c){6kM|y>|FuwgxpC&cpd~3Jpw78?MjR2Ss351JL_!UpB1&@1<_KB~(G@Z3n*sj zh1|vxo-xU%Ob5xod%C4LbG)~7_<+iN$Vyj)qIv|zX`+l70mJJ>i^ysyqUO-s!F184 zDuBS|>9>4^xp9ZDK(cGq`PjiWw?CN1^tQV9V1$AJEId~gEu>jIE@g~AXza()ue^)! zMXINDXIX6zSmP7XLI{YLg$w+jUG$nL=@w#cwVZ5D-Pyn_d`BXNo0!agp_*oIc2v{V z2{}r6VKbG?MnUNWKi6?InpK-N=;KsQ?r8MG$t`8naw|J}8znUJU_%RK^`fH@t8;r? zrAg^SK`MEdmzwA+Qe92d+G^A*f-v96*LjY+i;Y+AlZ|Y)2aM}ahr7=ggMXjnpGTkE zpKt|7LUs;{M*5;3e}3%y`1;&|TvR(jfAT++10p}Ng%X$JeHoE*nvxAL@8&K!tq)N4 z@02zXEEo{9`@BNrpeh5|ba$Q|e+CO85|M&Os?ihvHgAuGI;NS`pwfY|Uk-M3%!C+# zE#S$~=h+rltNv52`dC+HC=F662yM0yVV)5?Q4CqKC(V(SkEt*nm3) zIwV?xoA*T53EJ_tEH56TDF0PQM`|)Yrvz(F;G`Q_4crezBGK)LP%qa5Llxg=uqvVX zs@jT#_QO;`_DJCD!(0vc8nbLw-i1BCUm_Fr~o{QHW@!%=R%C{WNX`0 z03JFKwq42Y>+^W-Y%^m*9lh567LpqJ05112 zs}a4O*)JklY~`804;ks=bu*5>KzJv?siFRW5{AH-w9-FpXO#pZqk;oqe3u)v7&}&O zan0w7;uzF%co}gnOI53VonvhbMC^M1%y7{$N|;0xAmaJuMW1Ev+t284i2kDSlqxd6y_|o!Pa+FI?Wn*oGVz> zG8WNGLS(2(MA;pIxQGRnV*h|K$UzOOJr1pVaa-SM@=%cCZJhiIXthTly*5foo!1aY z*&wO53H<$u)b{w9osAJv$fG>8B^1-K>pqAdH|?YvbcVmZQGVl27G}9y>+V4?Ttcxk zQC~t~4-iIRDt9f4y}nlUu4s$*lrEMPYjsHhNHQ3PAaD_Z-;ra_@3cAQWM23wyuS@y8e~Hd7Xo?(Os(Bf)4lFzvA;|Fx(J zW$7R%dek&vx%7uC>!x*TReb(&u*Ft-hB6UVYpU?R=g^V*JvYGEx+7v@dBWttz|`G^ zXe&eNeLx-Ey#i6zp?PUqKQ*_M?8Kc0(&sdmCoh+H;@B{1)f;xxhd2$X=|q(UoRZR? zD@fD0kV=fXPUECO=bMGOj52W&_7QDu7jdc5Pp4B6f=e4guY}Ll4)#KLHR4tr{SE-J zwheSxnBlt3$ToZX;!OP#j~_wEFkLbpLl+xw4hBNjRI%CPy(5&m)YxKQD6WFW#?Quh zTCc4U%i7MMvQcWoBV4KaM~*`8OXN=;dKlMckZDi5GXN5=gn0E5aZS4@TDYNJ&FW|R z(L<-HWKSwTb^b6@)~}wa%fC?cjw2{%d`~hkse!HO(BwooZX9ofj#J25Sb`!2Kgn25 zRJ6nTL8;Gp@KZ*43HX|^+_vtsJFvT+4>y6+LhY6pJuaxlSPowOba?Xcq6J}d@VA)W z4Y?CZ%&QW&**ThOwv$}pFyJcvQwaSvXSw|NJzb>6gG+v6^J)fx!B=$2ov^oLBU{PU zH?LlwhoSWEDD!yHgz^OQv@v>#Sl58ch#ifKD#3PVd_E`<(X-{A=a~+le2Eic<)r63`cgi72w0{e zXMLmoFN&M*o9bGu4O+&LG-P38jE1uttFPAOPBggSA^Z^qREev%#qBff1LqHUK;iH) z<-^o!-<>FHe5T1?4y}yU4agJ##j41A@s^_TCv%Y$a9Rmx8Uc!W@5$sr2t<8M^9xjr zn``*lQ>7Kq!0)xMV((kckTi^CVz~>U0($*LUhq}SZ%7|*IED%UK+T~XoX-7Ah!mA z&e-z^Pic3NfT`41O7H;Z&hy|?go*%}@yqGUav`aSA&V_9TFzG;+JBw+uY#kiU+&yO z->Wg-n6GWyH#b$MvuVSVJw75i*(eDxkdj}aD3TV>@)B6j`4*UJ-wd9LYwSf@z8}*j z$t}pPtmZGse&44H6D)ntA}D2P5@baX`@fj zbf3|>LMh|Ci`4pw?YQWHxklEmoBw?t(x3s3g7w=j@}&sF)=Wa57K3ponQdh6lbKtZ znA23Seh^(7kl{%{{!w4RrR5u|ks7{>eLISY0q1&D72GwNR%tLzndzT{2BXHGTe6#R zFC0?zpeCOH6Qi(~icaV1z- z_sxHynhKHz0x-=26sR~q@&I?Rgzge`Br92?J%6N4Eb$629&?~T7R6S~EnlAmsFz@3 z^An%sh67^4*Wx0(x7m;l;7hgDdIH^WP0?0v>-$b_GR|L45?D3+!ZEOdFc&IDTsdWKQk)uBQpr5zP8?i)y&83B1I=NevX z_ZU94h1Tcm4+^)}e)@@h#{2ZVEL*4YbixRb?C)1LUoSKlpl6xh>8}>ZO@fvdp6N(r z0|miacDbO0@KKENy2z9Ui+84$&b(?lo3 z7SqH?7W4oI{c{AN{e(B{P(lk>%FPKEaw1{AkVj4u^A`UfhA1Q0D70nIKWn3*We<$a zL^WMVOl*~ghD7m^ipfv*FSyV+`KX)I^Y?b$r8_#6C21|~?p5nPrbU;TnhC+^rST$e z2t+7lc_2+R44IUJp3RA5<}!2l$l2tFmKm2X?r4lL?$yjSMgPgm`1@LxmBLBPw3~ej zYIfiI5F7E&mVum)5=d-=+0-?F`Q%l|e*NX#huO^ivzg+`9HEQ4{Z&ipU)pYEY>NUT zGa7?qZc+lLRs07@p;o%ZA9evQ3h1}2%D4N+8|F`c1m#Jvkv$X*=LSo~iI--I9GQmz zx@{mNSI_~1f;c6A%*{wll(sP_W4GmkOtM4s=3Yo@jj17TOD6mwqQJlZ6g*`SpOlw} zkVk`8{(U?6UgPZX!Ok#ui`gah$SK4}xSi6f4hhzO%VlI&X_VM&PeCqTsYTc~Dij0w z(Fmz~TKJRO^f8Dgm@-UrctGnH7zcUgH`f8YYs#W0;t#iUH4`qShSF92_R{HbR#DEU zEru{I+F-krgiU91e5L%cNW6obklJeBOS-2sg6LsrvasFf8rUEIUSS{e%|)90xr~iG zhJ(`q8^Vz&$!W-zL`Ga(RH9>=Y{7wnM*(B{uYWKP^;x`oj}d4MUmA5hUGOxwSU+TJ zn;&$rJ^F9|l!ORZ8nn;(dq_VqwjY8;DL4@9`z&PD{-P$iAN9!Ma_6ti{T;}`Adr&p zWHGPiFpv1T!~ZOZ;E{utv>~i9IQmuRl~<0~ucr)3xE|2fCB5xK8GEvZnp)5sNaos+ z(tcvB^bNdn#=D1C=_xNw;bT15V|$R97II?w0eGhB7EXo-1GMiIfBa4%j&)97 zYDh~q)W2T@#CMy-D^3{6n7`@mD-k!&8v$`ufjQ_5q+KZ z31QuwZ!*^eQ9`BHiLw1@^6FC~L%UucjLI_!QbfMo8u**gY6HopI9sV}ja|MGUfe0! zQvkeYm@fq=zI#raksrOco#E+tb5Jw?FgSnWV|KJ^x(vP?`HcVwbxAe9Zn8A=te^5r z#!x&r+UQaGl6csIKq3&B!zB~4QPns-)sYNv(NUJ{segw27uC^S(p-%puMYe(+QA{1 zm2bOtj}iYNo$U>Jr7kd;#{hiVx|5#Gvf?E%1N(7QyuMpvL<54r2qsce%(zn6+47#D zbg`=G*8@m20W@d=GpMfnI@WKITvL&G)5SQvQpvXEiW2*soD2(}k}%Fv4xgQp4&9-# z0iC-bvdI_@1DWTKlluUlF%Z&Tch0R}f8)m}^`Y6sJG1*rZAN}vlfP;edH+Wi7D$gm{JEC);UuLl+h%_5=lh&L`Yia4RF}Unq`+Ds*eVrU*!;C3`0aXJ zkQ1p|X>X@3k=A0it_hMnAw5ajSE={0c($i#{h#I^z@id}jU@`&B9WJT4CAJ#(043z zbTzPBcoZz)Z}0>}!cs@sgTH31u}95WuNcKsp-);SCwjWZ**%9a`k8JIyBR$NZv&HC zP4blO9&DDKsYc`p>IkhBydvNA$FX`AG*$(WS;lpztk2mUR{_o&W#j$xfRK`*Vh65N z$a^d;45tt5-d3ZEmi^`@hPq22n_(8NK^ci^->UGKCiRtB3wuhwDPbs19GW$&PSQR$ zDs2nP3B)9}%%#~`XsgNe!V|8UhF=y!mulxHv}&g?J-Ki12~=qSrx*h7-0Rv;iW(O72*)6rz z-k<9G*#ONIkE9h!gjD<-_geJLwz!QEmhs3qBd657{m`}awVmU~}it?gVG>4tbV zEWh*?i%_t7eNIsGF%Egaaau4rlKX*O!`$t=^Hz;uUP=5#o`M7UdvLT)TAmvwz$nBMvq0HD+kMa|DL6AUK6zo*ijl-l|BgiH*=WpsuH9&BJc=(Ivj#FeOnkkmAnoQ zO8#h`1xD8UF;EGWlm#-YgP|t_>IoZbTZ1lCxV^;V=4J4VnJVS;ZSCeYl5+pdp<8t5 z(avb6v%r@&^s}bu7C}8H@(-MxgWb+s^ieB%Yzkm*|_bwd3kGVi4>7M8~@MFw*oX|K3=$a1r~XJ${nm%~ZQQtI zc97^w>V~@Lwe{a`Dbnl-TiWsYn0-GtYp>5@G>pusL&3Q&_|gPbsZGN^kh^))bwME5 z0Gb}~RJCyd+&t~J%od%#dbBdNDn5TuW_nyOT17|BtoTR@kA-DgsaQtw_ z{%mZG`BXl*g}TR{`7|VYDQphvhi^vL;;WOl%&pspAl-*iDZW+}r_VAd=y;aT_eed8XWDguE@7t{Smc68tskJ8{D-)wMYm7V>S0GQv| zzdPJ(LGS4>Y?lRc!C-J7t_cgwA0#bcqD#^2;@+rXTB?Wh;@HzuD^I0Y>ZPWLAlM~7 z#IJlOL!k15NTf##I18%?pCd=`$dM>Trn8j^;}CDkB#21pbdKzk-7@KOitISXg?Z|| zci=%HElQZ$OK|J8DC64-@iN(_Ywv;ThXdIK3i_(Urc~5&WwW%+&K9OTy1f&yVYS$v z8D9!4{e6UDOmboDcY3YYMXE~M{>8(<-z>eUx$lXCOillM9-Fv;phXKy9R$AJSb($+ zUM~x-@RVEm^z_Y3`*OA$HNDgBUt^w&|i3wOcU|Z;KR;_NS~k7 zQcava34N>5wfusR`;}i?B&7I69t#4$#4s3!a;ccMHU~@(dni?OSrmI2f z%gM)B1p;yN3ahGz`x08s37ZXDa$jSf19KW!M(X;y8hW9?1u8ojq6oOp+jFI~?D97z zSlbsPt<|lrSnIRqxwnnWBiXPfZ15-e+ii)HKM+3+h7JOV_MD#&`u2~U`VeRciNU5m z13vZwKCV8m6o{+6VthZt{h4z_ZnpFU$>@;=+C zY~o*T!FV1(@cX4Q_a~h7*(Y_ZSVSw4WKyV0zsv>mBH|`7Gwqx@38DYd8v;LFIHsR( zhfmlDu5-+V=z|3StMnziqp&2=A9&koT|5>sV-I2k$6wgcu;;mkx(yPy zm+p7k5~h{Tzi8Y^Qp2|;kyWEs0BEViqR@&T^5C`V{ft&V{APbH6W6$64SV@}IsiZ1 zZ{S>fvc5(Jv~@tk;r^I851!X4t?xM9PBxQ4sHgeOj_-%xWW6Hj8gJwLmlPNoHyVE) zS2pWwpJDH8KFk`dmvsZt(iq9#i&GbJY-n*+VPGG}h?Loo!f9`q3;sK70gn)CShJWylstafu8n^9#qFy@i*go6Q5)v+aTalT zVCvevxuimK(Ej%RLbHjXr6;RS3fc!7gc8!73bO@Yg~c^ zcXxMpf_s4A?$)?F1b24}4#A~?;O_2?TX1)0*!!PzX6EL-?zMV-{dGN6Z+kqBw^(MdYE?ppY%5U*z+2D zR38rXW)cyTNihayd%4gC9hc#2?<<~&`h6Cj;FI3s!}fp1bd&0XruK8RbjzN>jBj?J z*Jid7f7PM@{E={d%u9S-DmfL2hxh{OieNrty3*9PAynS}W6@{ZU*eOB{)E7@=T^6} zS`eyUv!%}HdqYMhDQzvVC!U>KVLhznytAHz5v+Q%IT-O4PlO&xaSe@85SH(J?fy=O zGjY_yH8aAW6i9i$r%Y-aX&|AE0l1rSTdS zaaRZigA=Nyid0v+rWHeD@XjgI9GB0PCcqZQoTZt#!Rm%;@tF*LZK(f)?WKSCw0pGv zxGvhxJ0K^_buDM5|Dgfv4td#J;`O4T_*rIad$d8kMh~C=54t@tJBtZHX`Y-6y*}#h91_uR;`Q`DC{ngyiZT9s$*=mT3ROZd*Qkl*OaL z=eg@=%)@EEMgJdm8>L2C)^613bHsFuXzkrWJrmc{lFVy1Wa&|qsS9LmaB(pBV(CT# z{>w@toTom*2u9Ld0M51{nLs@=Q8Qv{3l)5WzINROF4Dsz#PW{j)H{`ea~PJ=u4Yiy zBAwl}de`dMeSPkd`j7ziG1EfwTHVAX4v@%WQO|{krF)+UEBvCJk0gTMrV0~3ZOH?f zy8FWt#&XJa*R$AkL}EyWyP41EA3Dl3#CGqdWxP*0Xo3)IGV5nSz2Yl~nt-^o2 z-De&pb~kh2-itLa+a4+1eC~775_`HZpV#pRH}O!uC15sV!a=vV5b!h?)%=TZ1MUC8w^c|T z7AYh@pttI;Us)mmi3b=^;;Z#KGBn-M9%QLO39ii!Umtsl_^SWKx5r%gF0;?r?xRhc zgden}BJ~{IU%o(Ked60Fc**Tbn>u||`+mdM`qt3`9t+VLbk?8$;@d}kfrkG7jc>h2 zDn}3n*egkW=s?SDfMtL_hpbT2GY8|^Mfr{3%6Nf)kCqe6j<|RWWRycCFT4ntAS%p{ zmJ4*Mp{)wS8ypkk!9s4Y%0l4yt1$%9Hk^z5B5!90Rl;K(L(LQ|nWkuWJ?pmXh1pY3cBG})i;89C$E#ud;2r{1k%R00+Epb2MJ(_Uyj8VVZ(N@TkR3`Zg4wPI;ae)~kg) z*smE|(>{=Dpz43~+oncd>w6r2wRs%7#g~Jv=OK;sBjZEHER1+YriJ>ByIf8L`7mZ? zW8~AXKsmwrR2;~Wy8%!2TjaI%o2DfU)Uf}@Z@WGJ7r!lm;Q9?1t9%*R>AgY>=3hrY z8tQqj_sL@=A7e&AtlCR(Yhgbj#SvbC=^QLw<*CQ}m*1`@@;6s*{KIciJpbXhG)Y1K z@LP0r^B&~!K2%v*HdIC7zJL$(mlsc%Mc+-;tJ21ylknI-B4r~h1wnPD;_s`h&Q(Y~ zKjLOku^+@=vcKX#YIV|WeS6A8sAoinm{(j|X=>oa$=e9;R!l88o0xSQbxzK;ZAel^ zD`7W-<#^66eSD!0W!CL-c+274+Z@B}iYsjqdfAZsv**vq-ToAQF+%OHcIjUHM8|!l ziXeZ8AY!>^qL5iwVFw*8t@7+bhlB=sIl=Ehrv;i`il^yU#2;R^@Q>cQ!~qNQhL+N- zu&eA~CXp41&UGLAb{P=Au4Dn;7|IWxxUZPw_D1k5l=lYd7DrKjEaM^&a!p8`V~(7Y zg#=+Yh0hVtDsnF~5qDIjbwd}^y`F(4d07J1t?*5WPx6}1?Hh^xs1H9014$UD(A4w? zLRfZ@sHp6Z&X!m8bNEZd`ld=QmJzNMsZvNF+EV19kpSIy8y%z|L^sI$@EL2YdWUN` z^6O~^=d@=UP2>z;lGov-?Fa{|$uBXE()BT!e*?v}^Ilb6 z;CxV?Z$DQlwFiFapidht?CX_x@x#BRuHSUemU1Ki8`a%MUw$!#)WUDeSx{6qB*n`0 zZ9O}^Mi{cX{3WtIvY_4KjrGRs;4=U}Z;=}I55wgIul$$cI<@>ITdlzCL;qyB(K|9^ z&z}tU*ZqGO?onxC062AF6SP3s9Ts9ja~e)$Y^!$msY4GJBP{XOr^>f6c%?NdVm*w)AAe}@I*Cd7OX6(thB3k-C*ESPo0DLvX?bjBm_ zp;3N>WF^_y?Iy{ER7P=cLv0Z`MuZ*5a8~GoLCPvo5w1k)X?%rQp{tXWBIo-?Pkq|E z5Wan40EQFltHh=Mq}WFt=1J5%*1;5`Zdcycj?Wy-y?%Np)PTRz{Zqs`r zui|AWXxA|wdF!l%36yooAfJ0xl*8Fww4DkJgSVy}8T)UD>wwe8fwv$5hKx~9Nj%cA zThoYDgr$m2MEsb6b8_JE@N`P7cljLsJO21EBax4f7XA1W;eyCg^W_2*{z15C1Z1%n zJh2dgJU4&oPt9|D-R@`50$k;ck$>Ukb;~5Ay)-tZ^p4P7aAl-XO>`2AJltUn3Dr-z zZ~8|naVv=S#}g`<3T7rh!1rqpf~{$y;DwOY8wO+V7n*Lzj^N_Lz5SGpT1*i%L@`4= zME}YmP7k`o79Mp!;qkID&P_<780o}w71uxR`}P(`L7&$7xS7)VDA)M3bdt#|-9d6U z@d-nCqnk@JHd)@stoFGDPV#(O{1VJN*M|HxoSu-}vUO`E2;aYk0||};Sy?h0$&ig& zVU~`*truV@dZvQvbus*sCCOZ}iC+!Fpjp<*6b6TFVZhBCr5k_2)pRh2A`F^5a@a&C z!FiQmW=KpO7`_NrjPKRwb;|ALYjeuvu&y)M#{yyndF6PQuM2Q7RMmq%LLE^@v!~%$ zmWdS^CBJBcNH9BbHhd1Mr5T$_5C8(N4+9 zb1AS!Bc&5kI~+*kFu#+kVPPiQNYxz`v}5J;#76$nm!8lC^+c=|uKVb>{h|Xp8HHU} zHke?)(b)XF89_koX4&x+DOd68{x`d;aW}X(AT$vO5e8=J%^|WA+~|OI2?;gaf)7a` z_FFMX6_ea1E$Q`hF7DPvn(eD?0fP%cx=R-R30Al0u>*d(IK6lG72;^)?SEKqNZ=>S z<^PA}3dSu8806gd8Dq3L4`}p?UrIgDu_FjD*b^NGekKnNAW-OZNIz4%&Cc8CY}~O0 zAW1Hm4CKJ<#1gP#^6xn7vOy+ARRMwsOxRLbsSRTuvOu51Tu1}1hwcKrT!-UAaw9D` zA%bC+tFhdSx6Q8h2cot<4t5r0(P(I5meJuhttudU(t{acK;dBcOnQ}cslIq5qx`eT z%|N2WDj%sKh@I0<5~P+Vx-8fFdLiEW+Tb*ey`cZ&WiDy7QQYxB4#Q5)1nqayI*1A070Cl|-RHHw||L!o42I`3tZ#OPpQyX#ct_ zFX^SqC}fj!IiZtiArD>%H**!qKpDGbH`K(W8VtdC5(MuzpSnabr}xgw=f5dSY+DoJ ziyfg?kJyGZ#jm*C5wi~WtA~s$bRfYi(Wa2h?K`aGp^z=5uQn>;5!VV79*u9`Bb@et z6U<_PN%U*J#+O)*&(Q9fEdJhnvrU`@&Bj@->czKkM9gM7!6*?pa1C*fPVaJl06aaC z{KqBF$Xk{Rn{!=n7{uPv8&BJpr~1P1X^)VX{)TPoNV9pvOdmGQ7>KPKE1CX9&wn{? zLAG8lRV8!Yjd1+bQwrbVlpU-7FaN;zwz(yLKlW$eV8ZLWW&`7)mnOiq{%xn}w7)yv z3$%@5*;;T(bJOLA*s_WL=RkA(iWZ(jIK^RRL=SYY!a;J`_O1EMZJNh*iXZ8j#kYu)gQ0$M~XC2 zoFf5Abj)U+UZ`6|KAc&DqTfwRn%p}P2H{{;Rb*f+dmmV?Zy7#<{~@`Ti6hFZ0nyf@ zh4nqQv0eeyNys-=bXgakmz?u6WoMd!JIE$|pTS)VunOx6z8$QsoX)Y8rY|Tls;1tA z|3SH6sb2awkg4JxsSKMYWBaM=v_@TOi!=$gu;2;WK$#bwR549xc@XM@fP%Tf??Zq3 z--mgcD!y0e18x2q#xGNxal&CMg05rgOtSMG0ao+i zp4XAy3DZN+jpJzl;@rLe#<@sD?#<>f0p7AHpXuEnpXuEqMJ|Hus9#}a>i^*i2aaPR%l;e5Q8|P$fl{*qFNUNMv)! z=_@Z=^yu%Qj3NIQ&2{WH%YV11|Nc>Ye2NdhCcSkr>f`_8`pFk$?`<2L#}bY*za^`Xm{}`Z&HsuJa4fz6 z^=8S-%ESB)0Q}Vpk!mW8YBwo~@5cEPZ<^!RLJD2$1|)k97P?q)6$qEOC(H4mn|>b; zWt}95|2+}_7nqd+_N(l;khL)0J)14#c_;#EFFAyg&~ac#KJ@_>4IeMp{t4A$I9dL# z&-H@fGrapPf~(m*w|m_6{0Wg&xQzDv=~7nRM?j?ntP1HyD+HzItT^2^n{_scX1st+ zm?m0qwQe`BQwO?I^ztG6`X8K2;t*Hn2NyW29+bmg1Q|vSm!T*=Yn;Zl2m$cou=9ER zU8;2@=kR7P|;x@KRnMlY`Zphqb$4nARcq z)I9)-?7Ckorly;)T>5eOlAAbwqRu@zR?GSNA>VFxY%nBfji{vk;d}+J$|cqPPlWfI z;Q(wX+fel953aXa{xgeGtGx~S^It&UGGVAD-^^imwvg?MB;pLx@37GZvd$&ECu3u3 z*A??E+3X2}+wcCXn_?dIhWe}4vsRVunCp4a$Z7m9 zd1E=^&@lADKNa*C|5N1jhG){Hi=PPiFLV>$Pg z;7Inx!S?+k8TT_u_WuzLf%@)5|88J6ShF#<4wE;aJ)+=8d0*A9AC4P{Hu?y(x=-04 zE_zUsL{T!?Y|MCK=5nsu*Pg(xd+9v5fo-~O@n|5)Y`2f)%o2T(J8Wq(A0h8VNX^cc zn}reN!x}eJW5X7u2L7rgi2eQJ(yC!*@+!KEe9=V_OP1v06AO*a4-RUlxq&?*op=u_G;zN0p&m8605=>4HRIsN;YH<0ap+Zs zQPNsYRQy2s!lkh@D4}Dky2KR%B$BVltvu*oyR5>+3Bu^PPZIbtX#rX)-JE+0B7&u+ z63Su?w-gS+ip2<#@#f-EBmxf!eYP63%7uPDT!e-lGCHgx^#VaC&r-z+DJ7^iq~zB3 zMY@Ie?XRM}YP(1r^rHVX3YOAdBK2FWAUnI))pcZi=$oDH!&5;JLR#1v$;hHZ0o=f= z3W5YIMy4k~2*dX)I44_14nbckWLDFB#MI#`8nr9CsTw57m{GnM{f6+p=2}SLESt4eVnl5mX4WsB));HfX{i~_hp|T zavw@Ie}5n+)wt@Ncxhx#UPRml9SIEH*5lKvTZASANy@Pa?%x~|2~*Y!S-J)<>fOLF z&3z9&_e?kEt6>oe2+@JcDON|yTtoJhOojlF{LEXBig45(abpYD*TxW`=eK^jaoJcn z|62T3`x51@@CA)Gkkink+IJ?jAXu@~4B@1a67!cv1AD4*KM?x|Wh2E+ElQAVJXPrg zVxE43n@*xZPW>TO7d?_vuekzKaq+5Ym84dma_$TucJIAC{c~-uE7z1&-F`q2hW%DN zXZVNXTJSA_LN+1&MpbXE`q0oX1pOY98a>0RVi5s8j77_KB*>+d1>;4&sZ(Hz3;_W7 z`25z8%z?qk0-sXzQETcvqsVtD%DXz`V_Jdkr=qLzK1+V$!!_KO=~IJrr1XOfq?<8; zL5`W(CAx&A^43)@8rRg&q1Z2G+qa874hMFpDzJ_!6FuIv1Q!W^Q@4>b#Y54JN8^P>YPD_o!0hjxzCCt7ptikvTqgoT^Q1j>g989$wXM4;Wcuw_oLH@Q_Zc zc8qJ2iENcv_6!+aeA`pLet?32cGl#8%_Ppr*kY^= zB%bN?L|l+X!vYNW3W3X0Aag(Z)#-vzkrsYS^Pme0J^ObC#@Mkyklf7E(y4pCE$ zqIgV{r0yXk5HSv*t>^;%l!XtLhBlL)lPExb$>V43&ShZl7+STK3i<2_XD5Vwar(I_2 z!=0UIn~pp*o9D8MrpxjbciZ3(gyW4SJ}ZSLRdXICL}YXVwnTThF$1iHgFdeXnkatQ z#^qFIrk++KBLL61MC2ao8ecR)Bp-A`6|8pXAJ+cKDgNm9O1{=C?l#YcEbbTJYsKq1 z@wrWMGxpL|%K4^>;R9^8Go|m$wD*nckN5Dxnh-q%Z=L-0J5=G!k3N8)>uh)^!HC-c2aK1}8G^+y_o1`henXj^g z6n2pA*Q+4H4)4EboZd$qfpl)!ml|`3MoICaRE5g22G=y+w@879Q|y8 z4H;(ALGokuidu8Ypiw6Q-p%L5&PW1zM-u5CMV$4KqlyClPM$;Ur#NlTFN22w@^R0G z9iBn2(m_j;n1pqq(r6amXX z8T=)|QdpuCC?hxn@Ox2in!0^`v4?yix<)9RM>h@YsE(?G%{r2Gm8Z5MS@Liaq$n!B zPB(YQ=T9B#3);_!H2dNTkspBu*u1^pVVgLhcxtV&w7J|hzPVufntU5OsfL@xtBQSF z(NHLHV6Xy&Bfd1a1v@pCLrn%b06Laa_1v`@ln)@SjEVh~W3iW(HgBG9&Mh-Flp1J7 zg9la)OtGVw<`zpXtzB~(6r(%T=0`&ZNl}3*jqX~pd|AA%;sQFVHwz`W^X$Pz3o#4b zZk3$A^V>+Y9CWy1jw)Obu7TB3_`~(EG&j9k==@Y z@2dCYmGhJNWdnwhHe6tq^5eXy9_oE_ZvJmv9HH zvoW!!pKZ(CVKnoKZ*4V#=NGtfhY&?f1)wuq!PKI>{w!JIG-X=UWBpFOJkj{M9x$Pp z(ZkYdCWs|PTsNTdgRbqSTnmayu56)On@oZ_n>%4}%SdVTwmNoGrR*SCS`+>;t@j2= zPJIKu$$8&Ae*jvUfYv;{m0CcPvrt{U^RJ&PTU}|g|vAl zo3eD8nFd}HPf1PUplqa<)_`;W)@#R|N7c6ax(u~wV0^TnX!?bn{+#Z;jf`df?s6&T zSC@0`c*Ge?+SfBtN@Rg2+GT<^Wu2$Y>DuKP3w7hT646WK4xzupFMPyL6MCCjR_z&s zSyrzlZWr#6nJ@as-X{--qvuGRJ|D6T&VN1Xh94HL-VzS?SEhh@8a7YoM{j0}cF(^- z$0Rfett|49FmurHVfEt3`|3e|+!!pE)>p|EsyoEQg7Ss&-yEQaKea)ND$D$oH>{}! z<-}M&0+M`DbfKB(7QgrEvx??=l2>O%7c;w4c6ozQTWsXCTuh{`e52bbHvm;w3Nx$q z;S8yVsD#6Ti6aZv#(fc>+}5TOw+^{ORt4Ro|20nRbX=Y~mTS2?VmS7fswKaqw(U}T z+@k<_>D}|Yx0~>oSogG>-gmxe(qHEE=|uZhKtL{pnc`3{X*O$yNp?t|7)NNcdV`vq zOzULCcHAv0t4Gex-~cGuSE)qg5(-yCymkbWR~I8PU<<{(N4vA^q%caj8cDcDfzm_C z25SJe1nF-`kK(1LI}-|%xq1_TAZ^V-lN%99u18t0frx+ik&BM2N5~<5WN`?V^*ypm zYmA#6x&wF8ZOb6;+rsaVZG(dz5R$_AeX`xZ<8l~l3O(x>YfA%uuNH7F2B7wit*Pqh zkHG@rXRJj7PlLnT{a)dBI4=YKHn;nxovstkjZ|6rP#{-8<`+`Ca=Qgd6Q~m;^PdKi zb*&1^SsD$Tm8}4}@Dy3?!AXSQaK8>2v}^e$D@8Um*7-{?gsVZmPO%Z)mOX2DM81<4 zftX?ml4qauatk-B)u?j&X0=wf3^aAMIlb~7ru*g#q!1uZX&@tn-z3$rMf#!Wo=p^V zxE2-Tz`ncqpNgD1-h18M8D#E;L=$OsCq4|2YTNYS@ z%rYtgitBJgq=2`1kgQ&htLkQINf*}(c5#5))eP|NVY$`g-Z|9n&T$Z5uFrp!OEU;2 zkE!hx7{VwZ^HkfiQj3X^mz>M#ht}p@U3ZOA515nDR$>nZ#sx8M13Mf~CXk*S+`EACHC&Dn%#8ox5c{C!wk@H zyC?^1cWS@ftx*G;{Aj;&`bVA6yZS#=KK&f}icai(_ieSdOPa`?9ra}Yjxc2!)Mhc& zZ8aLjE;gjh2Lymihr=cg)fn!fM>9wFAgKPxVgdGr`_(z&Y-Ym>SHwbVj1bi{Tod79 zWxqF`UmRaVQDpyZO9)J7C>xA0dtCfgS2XK3hg6gfB*h8hD)577In5Z-1YZ5zXZ=>G zrkF!F0_2(Cn#iyS`6^$A+r;R0jhYvTv{K4NgcT39!^`&yotC$Fa&-ZEt2F;Tv2e=K zYk~-o4>IE7acE_%@@(!hDavSmvx!gzB%@%{dF+KUQsfyFIULZbmp>*HBS1{F{!aKi zKmj?JWLqee2xh0`1k{v3;fayGl5kR(lptJk5|&RPT#VPgw33Bbs!sO2zCha&ty#19Lx%xaCKNWz=qMT>==x(0jfk114yx-CE-t~ z*Zsp?=Ynw~drGC;9YtSWMbyKUtk&kj{T;4wc30r3S5(9tOu@OPte`~{H=h|&985=A z9Yl#Dp-E%xNU&IJEmKcdL%`j5E`mml>wK?gDUmaC3@#Skoku;*{LS!ovbH31y809m zKL%eX%}E6|rXIpazCJHh&T;>^(KkvL_n#1r()W>{V@>oI!ABA*kwENz3z=(2=ev`EYvVCb3FyhcD;omFfKV&|Mk&3bDz3MqkCU* zpdo}{(!w<{v0C*k9y)?z#kDQ0?_kD$g`{WgZ}g?qR;qW%jNe)DV2i7g3x5e6ab++` zOThNNOrxOnn!i2F1P<~2wCeBg(ujU8+POHsTJlK_7+zx?^EKOdvSqL08@8zX!AukC)jRg^!yU8TB-B4gU}Atd+u zv(IDqwO2MLm@Z=rEGS=PVjazOu~SXO8a=hSFW>UL;72^OY^(ZvA?*Z4^bANc{l+|} z)UX5nygi1qzR_P1x39O=vT@PWo|E9HQia=G|Ccr5GCKIYJ~=!D?qr~ooJW%@v9~?J ztNw2#fs`#8tOqfqNt4FXzdyS$Qhf&A9<){yvWnZaMze}vYaK49IQW}^3lFKt$0=K@ zk+5Bqh^@2jntxwLVf{-_|1^CHlm&=h@5rw7gA?y+;1@r>HWLsE9FlAKH-#a2<8DmJ z&_{HtgoPm8%s7%Lw7X~qUy)N>7Perd5fA_H<9hjP68T}MDe1xP*PL%bAgTh>O(iL? zsE{mSTGDoHAJ(9-^|gB7XSGk9mJ8YUBaXvHr*+STnR(wzObo3Q%Pz1``J?O(ZDaJ z#?Vw~f9a0lm0PRDJ43zvsFwkcBp+fsEOI=!EiBR3w{IA>a|~Rl+-D2*_Pl0ckU2Xq znySKs6}ZA)2m`|rdHR#O5=KY(aYwZa%y_VAQIgefes*057PQ2LDFkrz3ZkpHV%ny~ zZZtCi*C_?#M(r7HUQ>>ja}g2ySr{PmQg{kx1;lS5fs4wm_UbkQ=5A=A0}nylSJ*wX zUpP9gll-1l@p@_+?EG^iFR4!K>d&c8IxC7Ur{uYtL32}dbOai+{@z;K&1*s$$Jp9$ z*}c8b7Mgyxrz^{=vIsQ~9?r9@scO!~WwW-D_*xDQe5SRf{Tq0p9}41kGGf6FzNu&$l@$cxu6Aj@*JMWWoaM8U3m71pNi-H|YfZJ(GOIwSDqP|xfg=y#+x>O# zZZ?#9D`RW6`d&hfsin8T7VvPyW%m}*tWL_}D?BU#|pisz60$pR+yTM{ugSGVWd$>j5=4 zeTUfHKZ<3gcHj1-fl@uK$CFiLo{pK?a`zY$h}5}?n$)3v@LE#$(4SLAY^xq;E3z#x zHU_mcFTV$BbsJsIUWd+n1_Lf<9cu!`^x8bw%g7sNiE801iL3Rw(<=RQv}iT2HZe(y zs@uuH`U2i3d)O@WP-?%PfvQhA#@48icO`AjsCOtn_k-7t%s7y)FZJ`-(EM^vUk{&e z6ihZa_7zP0G$yvC#DyQumLC=go9G9c7m57jbzCUD0>>W~h~E=<4*#Q2P%a|g2|xAl zu(2#u2I=fx&@kBVTGr#n9D+T_OH+|!hE5iRVK)1C$s84R3El6H-E@l)RHf!DMq~Tr zAkzslWbWPrP&R1$r&h9~l(eJiMaEotTYR66Wtd&xZ zP%(*=dS`HC!QPabwpwGTp6P7(-)O8N=g;q273C2&Zmtp)-+V6R~SbDbh_70rkvqmiTsXDoTP^)2}|%=8PMv5d@JTSI7{Qk z!vP5*qQwFj+|qx{V8d1hi9lVX4voOj!YD)SGs}k{Rzp+Q49Qh|Rk?y7=3~^Of+U;1 zDckgVIRRY~MSXevQG{I%BgAkV_=B@dvoS22H5iQ8d_jCWdmgniA)7uazIgy#$w+^gO{aKbLn2Fa23^+`GcL?h53VDi}V$Fb&gHT~H~qVYf+ZfNx$^Z7F`bkr-VU6-5N*{Q8W)Kb!GFheo8^i{PG2;Y1oN?8vt z_|QLsAvC~bBFG^3?r;&#G}Mfi2!U4Tn$2~GZ`do4#XEm;T4Fr|hU8~%?Qf<;?!1G3 zcDcl4OhO(?g3W1*kSL8^VbZJ&y?SV=(3ziQjUEGdp_rAw=X&gYuz^XRo2ed$t#nd7 z5W^6q3i4YQtUBm(9d5^e48K~qwT`Rf3G-lK26A9FXt$nQr(DU{;D?PK?|O30?MpB% z6}EGm%(HSd?|HA+2OkBKWcLHggk6BDoQrBY@Y?L`SK(wvU`X5Mvu&xp-iV7@zFI-u zE7EAodd+6;W`Lh{wQASzuJ?mw>;e}C^gBP&^>3a8PORK!<~}tF25aQkDxOijn?`Jt zz>ZMcAWqYl0w&ORTLc{s6%u1d;K2Agc+%vkIQ+8Rr%35Gj{sOTT7`?2wQ2MK>Ql6> z;IXXnU>r88!NYbxgD23TR?N?Bo1OR0X9p)3o1N5m7QPAC;)O8q z*jz#PY159j6S}QuKPmHQ6;?^dopbFw|UmW}aK0HF)=ynoF73O3*L^rc_*P`=4^K`ePUD<##8tLjTZRtukRh1&o^Q}R>! zGZ5XBs%?FZdspdAGcA-5>lG+kQv8Ls(V>V&e&ue49^T)&Y1{7qIw`TAPKvqr?r`;b zJ)LOtC^G#DDRP#*+~o;?b@hfx0IClzxv^U8RigD&nZg5g5V%dvrHj459(=~Zh=M0% z<0Q~75r!@h*@KeMCvRMZyKtE=J1f_Xk-CLZ^_aTK$2q0Wi#BIu!V)~#@#MlgLK3w} z+s>|*=PeI_s`6tg8dKfrt(i0QuamwspR&6@HJ=jdSUG8iUQnXDt`7r#NEqkqp{%@I z8NM5`B!yS)yBBZEELS3-p3K_TtCNRPjcQc>{QEh^i23d%IjGrz`G7M%jqXaOI^c+& z5w}e?8H;(LZlqbUYcdU8vsJe=nOga2pkyv6fUJ929P}^;ZK`e%aac};H|@W>Q`0nX z4xzc-3x$T{37hu`)AqK(9j-j%0|<#hoFk03%PKz11BeYuHAr(|RXR54soGK{BSy0h za~_QtEn8Sx!Q8qebYr8f07WyEI^Tlq>e#Bjw|SqtC8~D~FSQ$O($8X&;+ViZHh8}r z-`D->s|osz_MHiOKkby}4`9#R9Tcg%GwPK@&1sS-(S`OZcoS4j=8?me9#731l=$WOp3cOv1X;mua?82W5FG51B%AwtL z*^|lG+5C*frbz~$CQ8-8(&|4Z%G!z_#^G7}$)|}Dj_mfOf+Dw+-n)}MV2?3#3I*qU zB=@uJ#Q{`UdiKo^tG7+DQ~~K*UMGxuWR54F-V;Q(5=b3ZNJlEfRP$dGh3JF0H#T4N(}r!Wz9(AXrc%X9+fh@N-RH5y`#O3da@hIH z)0>vq;OL$4uaEy>zXRoG;c=GS^DXWbv5(iX^m<;2el%@yV*a&s?!nE#8uY!5G8@|&*DoSMF^5hNZ40Ly7*FvCqUmO-%a@j2j(*2pN@v33#Hjy z^1dKx{iXW{4BN@N0uzbP;d5`Fhr7Eq*4;!5uOvf(m9g;9Z&Pd!`u82IUhlqYx4nsv zvT4#pO?5^IXR_`pbuGPVRTL(Fe*F}EWRs*{77dpm>(XO*qSTn4oi<0DF$a*){%Ohe zc5(N8Qt#)_LN2dwa?eg1jMLLL1@Jl*p&FVjv4$kPRH8{Dv?*e7%qwjIHg3wYm-qxq zrypll#7(o64CG`?9qe|$HYsLtjA-dHIqk`H87WR)RQKY^hvULV!SUBu2lA}yd}_#vEx|r6l$!YyFA@lk+ngU z!J(v{$?D}?V}4^9%;Sq=DT@0SM|&&i*DqK(OFUogVdSMcg)L2MoQG1s20Rakc9-JV z#R3U!yj|qBB5>nyCr_Fz%@Ld{Qr;5(aQ`TcU&ZKhYpL3LmjDV9Ic#({v?ph!^B*VlnhVYkU?dCcZWqqs~ri7N>)BKrYGN=Gz#3 zQwf7g+v!IV&J`?zBTgo>y)(It@Kx7SZ)wYUUT`Qema?PK`SS6q zZJ@KdZ}m2eu+lerDBV)CdYyTWOQ|h^-K7ff>THRG%&o9-@8?+81!`;Bxt&k4Y-vGbNg>ap zp1a|P+GGUB+NG)M02!pN?@k7%dWD*^JQe$`7VF{k;qD@k;*pbYxsO2*u@{}K6XE#^!r%D@Yn7ed7~)*bFU(Kj&D_j(;Y#mt+;t!i z5=^-n2Ue#YEq)Z`4AuNt-C&IU%OO?DDmM=@SuRo@UQQar`)b~>8f&UO!+&y{xn#yi z3mZXT<5$i}?x6CZ>Dc6ICs8x8|B%?aOTQ}q*Lc27W(8S!a5++2mViC}P-nA~{%4hO zhbFP4tz=k3OmU=r$53PGWbeLal_RG1S0iFd6KMLi5_&xqct1_*?eevp(e?5*!6G1w zUsT%U*sri=?0xcG;$>r;&MENN_OGp84q4mI4E#eou>*pw3zz+IVQM5Xg4GhpLd7>}Ka7`+wPTOtxC*hB>DeM3e+Xrf3bV@3lwCkyiT1Ni$F(=G;{>I(DnCjlkG=JWh9VY?*7CUv>?)Eth*FY8tW6dR{B@-glai^{^3cANsTeKHisJ3r9l->Z;k2_|?W#fdXn{ zFK?m!iCteOaO>`V`}L8x4c+1s@e&1JmmKG>D(MdL-aDTjQ0j#aovdxsm~Pv~9`}xK z7%?;>6cr8gw=i1C)u_qQv{^)uYa21!X^171qnYBX>bnYfo((fMV!_HKudxC#Wimm$ zgG(%c>ry@2gjyL_DV01na8brsau+u%bwfZ+1A4f`Hc=^V}eh5rrA&2rOHwE z-sm1!Lv!Hu&?O}@#}xWKj@=W}hzA8fum0h>PY4&*54NGyr1nHSq>e?VqHsy6nhdjQ zkFe6qMKg~^51)sIg$QE>l?td%D)RVgdh?*Za?fyXh@W(B&`uQBg&n$0CvllScj>8{ z40S_RgIB}Ggn0Cu&F2xCyWxa^x-Nk)*0iP+@utU1`x6LfZWDYzCOj%!4PU5*Ru{3+YpUO+5c8t z9pvUk%XvcGU*YH>2yTBz6 z?j~Uy(TQ+Bmfd>EFCfc=nsQi#poimf2>HDY(YLRR<5~xG4Nfp2LmE0gnSbY?i0XZy$U6gO-YJq)67bQwrC!uBX9JD^n zgRTg050MH^Se0IMlGe@v^var(`f?~|C0Dx2Zd6q=kuL3FI^+1x7XdqpA}%do`lBDd zdP-26xwj(~R09TTIFnLq*DPBRyxeU8@`68dmFc2Dkpy+s{lZmxZg;6zl6PC8+#t!~7Inh0-&}4q0IMbFu~&?Wo4Pxb6Z=|MAvWJX%EtSoRvY~U zCZpk|f3_0w`T)oR6Cg(LxE6RA!9VG4pnJB2073vuGZV5@Qg*u~$WCp>Fb6nh^IIV9 z0}O*=bv`wwHz#-`h}je20-GzZ_02~%wbay8Hr1Y1t4X+RZt7*N`3}8=ylW^K@2q$+ z;cp=G#TM)B)EbbN%LQ=gXTN>5$9&ApprFhL;kFo-v>M+_neNV1Q$9hKfgpunxGk2%uD5BF;LrD;zn&emGvUD?m(c93Vn?LTAS z;qu5vC8o#aQ53rhtUj8PpPL10^Ufs(q|wh8^xj9MuC!jL|8^a*cAxYSJ&oK_iK!-q zf$v$ud8r&6#*{3pNJ6Xr6;xwe)*DBFI)K;_!}8HzGB=q7M*(2|vmlt3QLEXu}H^8X*#D8m&Yj{TrJr z%xS}=p299=+;-R`e=gf;B`d2A6r!Yw=P@`rhe0lLHMYD zdHekUXUi*nnW#!oo|a-e1ZpEU%?`oTbm96=(MI88Xpv(LoMAoym21Qd;n>!?&RQ4o z2`+J7qr};DMR>}VnLe_=aRXI?FXr6%ZQllhgc~RPM?SRT)Dx>X-mCu)REKwP>)gdnpu>uffn$Z=tYW(|IQ=2^MQAS=vhRCP^IW~} zgR3lCd7%62T4celYY4mW5Tx(v+wzMJo@2umY8dXaloB~rV@^bVy)T_vIg)kHbi7Sk zg0=#j+y1_W44fU_%fYfJtehPjjVuF~za?{F^X0~N1TUV}Qz#1@UPW~(n$(~U(BIvE z!sgJR*XD7JB2{%wU|>RZ&BrEdr@3F$f@IkSAM>yDrBPMnrYZ@c6%o%(tNB2wba*T# zA-$JX+s@SiGsD+K&=5{+*O{8FZc*j5c#=}j3UTzU!zlsV2pyGCN8}8qE&twGlflHG zcw(7d^ms#r{@RzGH~=vJx3O!!IUxL=T{MV`w+{rRM!9OXtCh$6m58yk@p8zDNfKjQ zfJeo696seLYT2!!iW|A+$`V;1SReb{ZbDxwZ76G#){$XI(oq;a!o8=?QcJDsw2A!N z2oQNqdZ7DcFp#6MqUB(nzhdl{$wWdnToDqO>DMXJrDb^S6#K zPtPp1fok0Xze1Fg!${p;S|g)fjNV*h1gXwdO;xny>#m&Gf8pT5AF~=xa-8--QC^Y*}Q9=wfCu0 zwd;Hte_{09*VEmb(Ut6lX_TmPV#sy}JQ&(`S_s=-G{E2c!T%KA@p+d~4O1JzQU%X>%`84<14$)ptLM_B7>tq{gF3MYEJixk zM9Y2Svlv0=&7e4r!kMEEOQ@=Wbih2KHXjZ~^* zmM`K=ZN(hUXF;lMQAc7?kGR;U-3&Al0+kQE$ryfi%b(Xc3`IfO5V3J*sx$REOWq~t z823+jLu7$ft2N9*=l>`{>qN5G_QuFuDSonsIReNi#~IPGCsvvy9x)~_JB=eT%COi; zmq<4Du-rtE{-)8GDEKP4Pqy;7ExdEu^vInPL3%Q!f->VBRk?NI-fF?)6oPhKKdYQ{mZEZ_y_t_O>-{BpjA06#n>EPX5y-AY+N1+-Z8udhDF=RN1Fnr^=ZKTq{_R% z{G^mS4?sfCbpzDiI9fwU3#gyHwjwX0m=1K)Up#*z#G0uoFp*(C_YmlK$4U}sJ58j5 zGL_WE*FZv2+cSU6IXElh{3R=P!b;mBC7KKzcYDoVyCPB;2v&<~kkj6XUAi55SI-}z zx@R3 zS{nBz6Z~1R&xS#}%LeKwHGa$*vNe)Aca&!i$oIEEDEf z&@uPc6r32P8PKsK>=I}|?M`-uTdfd9YRRg40+1B96r)TowHziU&9m>C$cnrRZ#$>Y z<45);jG*}ztah%9Yx$KNHemP&H0x^gJ5gR#4OT-UPn0qyKMJr;_%LSTg7fig>_}Vc z?P+5ne9ZfV!8T?dpS|E7uwv_0ZW#Qt?Lls50Oj#bWO8~Q>=ZQ0P8+vL zqXsp}F9*x<%65ba-ALKPV&oRG8r@V%ouLGXrgAVzfGFwvbR5!Ci;#gmb>03Dm zMRS&)d4|e3nPp(UaY~Qc9s|tdAtoE!AksJ7}WJ%#ZYPh7AC4}A$ zZnKxm?i>DzOJH5xC@1V*H1tjFzn9zv|; zXV3!RG=oi3#Rq0yDydP}y@cWbD|<^MxA&6QEnQ5~IGDCi`JcML%eB#D=kXO;>H4C`S(?z-3tz zlffOG$4=AL1c%k#U_8^s&I-fudV9sIcYs0$5LpEg>wDy*b!E5B`vT=)I(8b}#VhnjNf1N~TBkJ3C)m?M;V?Me(+HW~miO5jAz^#j#1V zGJ{_UE0cqlEc$1S^jUDD_6?slgc@yqFu8vul<5YXVs4ecoNU>GgBQ#5;+(K{dHuyY zebo*t#U0EdxR%I}ew8IP5~e$U-JJ`Pum7>Kn~&R@Wrf~AD)l>Euv+g>pzlFI@q`wa zGIlo4fv_5Fl&PCRAE_0rQ?BN!iiVOt16<%SS>M^YyUKP3PdRYferU`p3Y|RN@zDcg zU4)E=uC1LgE#K0q6x1J4(Sn;Xdkv~`gWZQu*_D1ci? z-5nEHLW#XTP&V1bWqEL5mK0S(`d)`=hA?X`W3qjE%Jza0?f*`iYjPXQsAIhUHXhN< zdFH1uhrw@i;Suy7q-}yO~>TXv*6H9|FYimnz9{dQJj^3j_XvZ(LPZVYaOF~Tmtr39)pb#?K+`H}ftPf$qpPwEl77@<33+O!O z$>WOiD-YEwE~J1<=wZ1K!F&+&b90e?iqxXn=r0=-o`kW(p-6hpTv5J z96-l(-7y7kW4#HRY;}1#F`c??74{~zpz1VVl9OGoo^I56+K?%4{QRn96A`+S@qx){ zVyUoef_R|4KF4Pg`q;wY(Bp@IO%Pj*P2c)-v}w?fc4 zv8)i6yX}QhbP$cTz%RQWP3#$4pDv~yylf_}qZR1G~$6P!$bXoRFq1l6_BTU{ls_n(VP{2!tmb*+}v0{DKyddfUm zcH*jpk9RZf&I068I8)kET4f6zs^(*v>XS{0SUQw_|HES_vObTM^8 zysr&qWlqcU&dcA#df-`QuGB(j(V7U{@!@+#sAxpns=DFf21@)AV-iHLT&ik(vDN!_ zShB15T-%cjTxjbP5&Zd0TkH%rDWS zwfe+uq*CsQiJB&*_DRJ-G4bh$`oAr_Ny; zZl$wqO0lb_Y|5nr>znA2i@8rbaHW>t+1nyxJ10n7Dg?H*t#bM*0{uvHwx%dWQ4Iii zd!fEgb&`Q^mvLNKFCC`lHc#_re%-(o{Oq9fGLrErlw%#Ui!vw}E)B^rL-)QJvzy{-X;e2b>%~}@xnvQ?aWh+oFse>g%mzG7m!E=w`G#fsJ{BtR7C9k zZoJ4ccEq!y*9ATrvQj~O;Q6j05!2j}z`uIFw)21Ui_#ar0DFD&KEL<{i|Oox>A(3! z^0e{)$}f!dz}5fo3o^(5;g{=#bwmCZ%$9q+#y!znGAYcIHOhw8S;r-02wv=W{Ky3^ zs;333D-Y zHrWk>Gt?+m+NN6z1SqC0-~Zy;k$rgRDPwFf_qW&VU#VUxLSL$00qUQx=n38QF$LS+ zS%{uL{u&KU5a|GE z(qAbP{?LLNEG0ub2jI2X2M(?j2XOInKqX!rQVnjuzZ|-|7b}_Fs&ajO#Jn*+sWJI3 z=k!-|aAVGhr}CealnW>Z18wvdi#=kKk2L3M{-r$75&Qc!$u14U+j0ybFH{eh$a64g zcxX>2V%yyEOByUs-6aT+g{hWcAvJ`3IG53T8N$-16yXEK-w79^&xUANsxs$-2Sjys zc3>cKxV*JO4c&0wBc%M@>3>bjx-lj|zqAJKZP@~8Didx8(54&2dFC1v89~eO_OYe(G-~rCTn&`nNsoV^_UL%YgyA3K;lkiJMSi*$2CrpN#1R@kERE< zXwv2??v|Lx2U+odlYm-MfE3Z`0{jGBnR~;q)c4y7n zI*D4`*(!Nv@B`$HskcM>oE5)G`|NAUZt{k0n6;>Y;$S%@H6T=7!s?U5LFh?>`>-`I z;EgCccoVZP*xK?H@k5iCqRFZ_91{_MO7eA+6^=kp-N-jb{@UEkJnVbk*yQ#iyfyJ* zbG%umH$FR~XqM_$OSNyHPyWM;a7_9BqWp)2-K9Nq(AB)ned5_j+5zE+MBwi9ZEvL+ zO&O$3&;CSW!21TKtZ}pfd(7CW>GG?4-F{9OKpSwPWEBv%GM7wilD8hOOBz zmWOBUbnDbabmSKBO5)4sDt^X^5@SvNruJ#)?$AQk=4IU_lc1o$wJfw)AWMx=h+8gi z(M0kyS?q5qf!1rP@bN;TW%_D1G_J5RJ`*!8`*VyV62l5#ULzhp^X)zff3C0a|aFI+68N>oTjld6v}T&oNr zSD^}vYpv7DZUgS&Xh#N8$zG(ckk?gX%S2T@_HTNc^#Ya=cP@5qmn&`OM>_`cJNYF# z2^|v{6`BG!ZDPk98m1&~jI5L4fVy>bli%23NPcC^pHTOv@JtCPEty7*y2}hCExTmr zy5C~0X#N-`)KR>VUEzkU2h!H;M^mzm>Ruz`>{fjB$*!L+EJpDPW8*d8d=w-}b2Y|b zLRD^29dzN6XxvPcuI!mp?C64uwxZgRbyxrcc0K34W+a)F9HyjGLpd1@N}+Qs!~`}Q zQGHI<3Du8|;i{$2)t8vJdl6_aOE)$9{!6tr;f-N9j4strjpmQ*_~UhDfxgz)_&w>o zv0poNP%QhJ4Au42*r#1pZTZm@+vV_!CtYB=e`8EHy+)i5>guel%I%?4Gzm1Vzgk?+ zAIeb=ycV`Jv9o4JY?K^jMQliMv-kxTOdu4XSQ-kjebgXDNo~M-`r1O8w1{2}Zp5?; zR@+^B)Jd&3GYw6mNQ_RWk2OYC{Ee=~7vZy3u!^^1%;!z$rUBEZr?VD69MN#O(omzx zCQ>EIpf(NFBPVgDxtuyOcKfGSJv0YuWp%mEuZr`*(`bwOk65OyYoZr>d!mA0kdsxW zf{*cF6yy^b2vSTy*PIz<>c}dOUq}w5IU0lL1<0e;Bx|Xq4!vuy+0%mWrp4_(>KAA| zn`&Ew++9R<*e|Ui zHOZNMt+c0DNO~&fJgU^U+s)hHzRYvNtOjZr_lY{38(L&5@^5hC27K^ z-_Y0gW9f~6E{{nyvW}I9q0Q(bF6*|xq+Swga89oNw;w|D%be$&ZvNtkM)Pq3+HobB z3}25n3v6LNFDV3Go+@S@&36992%I`aX@Q(g<6TN1=agHnJ*O$#?KJ(ozIVL+qNE5zIDl zq28N|)NFVqn`$ZzXoj1eO$ZIzf8^y~A6=Q*Mt{u$%29388^49KUu$9O{6}BX{zqT< zJpWd0P|?5e-a^;V|CZxy4Z)>^GB7!-1OBqY&8@67tNQ=yOVK2db084zOJ6izElb9^ zoEZNt_BX3<(#dccsL37+f}^xyu+1%FNX9TPj}oNmEu`ulzcDP7&af=U&E5oTvU)8g zHS!^%v45M5O7+L_nN+VU%f1qg74hsRP_KxiB3 zr8f1h$JpV7>izG;QcN+|2+aRCgp|_p?6nEYbL=14hkRJO1ACnAg3FXo}T z+l>I^JUstov>sgy^~9dpp#t$XF8k~36E4h6UrexV|G)U9aq!Od<%?eomjiW3Rt3ZS zZ7-JAdRIu4C_OC^_6XGk`O#u-#G$9S3 z+Hud4;UpGe!x%8JIPuVA)~Cm_d}OiKGL$v?)lBviC{666e#bnN%E?U~hz9mF!xhyP z4aJoI;Pf=b_ncpoR{nk5`W#~+UaBd~RXa%O(=^iOU!#IV`}79`8Bq*rLvi$BeUWy! z0A}Obg+3x?v2fZa_V#7zz2=p>4gE-c^b9ZKatU#RfLj49JKenDF;Y{@Xjk*+=meLQ zcS@=(0=4$-&Hu?QqT>I^qo;C~$65TK)J1-{GbIK|x@3;*ED@l$@7domZ`=FW%a4~t zWS1V5MEH4_>@^igTa>TZ=urFzU&iA$XZgSIW$m{0VTk^Bp^3s^y8a5O=i3XyX@uK@ z2z>YEL#Zu6KoE7h54?mnx3Sbs=$~PGR=Crcs7lLKGKZ#jayc>#vcrKPfsCX63e>kD zb=6Wj^&i#)PnJR$9F`^$nd60Oa<*;ez8zl`=F?0BS#iq~DzB*I2#JZ}zj_PTll&Z@ z8%Lxyfk^_zNX(bL6r6t9%f?@YFMEk@`;Wbd+t`rW{Fl9GX+prxFe2%2XBRnnMAN%& zk=?Z#e?K-1+#SDMgh(;TZ_Wwt18r&6mzSznt)k`bX~WtV7;m}l3gfSA_z1p8V48*4 z?=t&j<-2w}YV4PJ&$KwB>G8(I@7iI{+c#dRt)KM5B?F$*BPuqm5^P~}2qXOzl9V!# zwCN{id|%mwrkY>WWS7XK>*H+a8PH#&%``Eism3f5i~98^Q{^6^_O}LHkLXcl3xN)O zV090gE3OaN|AvMDT*O1pKZRK%hIC!^W`sAYZrZb8ZZKi}^ISY40z0*wuJ|8%*e%cU z)2UbE?ob>u-m=4wrQf^iW34jVc0~Eq-ODegD-vk31)7IiWTIDnH|@5)Z%@WwWhYyes~_%c)hx0O~{Dfai%VU4Rujx<{88)qY|?wQm2bf3r_ z8*VTefhK_w_Dn2!seGVE_r=nZK2}ste$jmZDT^2Sf&Fxx{rXY6M4|crO=f|IsdwuT*h4WT( zbqH1~5r>A}jUPzgbCll-46^z<>6l5CKt_%{N*Y!L=EUs#2kkFb#7Rtkr5DK*?Yt5^ z2jXWaa}u}_3^90ChQuWrA=+x8RsTsZQi-~yML(6{8z!f}4)pRr zT7|KqnDhknx(t8!?ELyEx!tI6y@x9<(Pn&@o6XV;qfchEFFvRxQ}l;Er~?$(+$g<- zr%zw#FQ)~FBKffIXNX64cMX32rleBR5*0Szt8tp2`XOOI9`bvlLmRT1qkvcjph;a@ zPtdaZxEFG1$;MP}T&_2BHozqX&wK~FTjN~qC5vOjZl`dx)P|>Ns zreE1hY6`>l@sAVkd=zOeGhx;v4nt}t2h&fms!Dbd-aTe}ET~w^jTR`3ATvRp$ebfr z(TnzH94j@mr)DC8Z=Sn$K-jn@ec2JVK@LIwiE6c8J?6?j0;!@owcn%57}!OVfSX}m zYDKd-pq^km5&+;Ogti}`wlI=!!rHNsCK+LLF8+JiTD1MxI^EhCi`E`C!-G)93?1f& zv~YCxVhfK>b(5tOjXhHYno zX!oYlh`iaKfOF4jUQ#rZmtE~Ca3D`I)Oppuc7EyE|E2TmtcAWm=Fi#B7ZlZa z^U90MPk;erjXSgdCwH;;@@u&P;P%kJ7&Ovu{`xZO@BcyDm)W5`8r>^EDW$1McHX!$ zx1?KJqSRe5+uNt~vd#F%=DKh{bKIFmean`x4Ygi=QS+SSrrm~(ItKo1sH&z0OgPjcV7sR+9af_8f zE;1NuAgh*fS5kJPIfpbgxi|50X3~6hl{eLG#16zIGbuFHLfzK5UApLZ)p#^JerrNR zHh0kxZacWS+k{`xf~E3Im8zq%H|}bglx^UeNB->6MiBj3T_yDax48fT27|zo?4HmBcE^E-Q6JhiVoK`j^?mOhjjFh8c$6qFvGQ{eX*@9=@{fmc zb*qE@O=1KdR!N4nD|#O|iXhNe2=DQ|8TFCNc#o&r?TGc*CCJF>YA6>%{KV>hpMkEpPd;3CS36~% z^;}P=(!*za8719(SS!}eX_JBBs^LQK=yn4HPciULRGwKaBiYAQ$^Ye>2)`p*#9wkt zD8k06Ii`#mI%eP`PkezU4C6g^4&hHJY;Uz5@TX=@xB>_?m-ECQ@i8u~-2HkR1pTAY zD>%{t-uEZP*cO-)NOOuH=_AVBeLJgT0!NKo?eB+4ye6is1L@V#*Myw)gQe!rw1DQMFEM$&nNu$R84Y*@#DJR9nttZhZy{oUbu6LeD&W&3;1`8kB zKUO}e|AK}6;f}uP;37l?ohN}qtZ7Tm=;4>j%tn4GDNVL2ZnZ!YWI$v{KBXbfkM}8C zWN28Fu+F4xKuoaGhGZ}%@G`P*{s=_ieo9uSz=K7&2)Da-M+-`p8rh;J2SSEpf!{C8 zgU{e*C#t@}sH9K8r3IaW>sS5~m3Nfhcsfv^>#gD}KEnK05=_Z2)1}?*QRYhMJ`#Nx8|@(U3Zc8`^77DhVFeuVT#}r9qK29> zrr5oOo}9&b>RhcTM`X}-i;5;7zn59sIsz<|V`u8vHFu>tL8l?Y)hn~6s}h)tb!9_q z*2_@7mUmaF!<3fkTi_ z^nZUS-($)2FDQ3sgNI-Unew0zD8WEwPz2ae0=3=n0VRPHDV&R~u8vsHv1aI?-5pyGek zX7sHR9S>mJ^|4q~S6G>a$i|12(F7tLWL)?7xhy@7k*-a7uxw0#!rPc?vH^BK8=Y~M z=TX^gYVRy(BXLH%lqgx~h7a|*09+%r1t|O8{*mNOf45{q?6>9i3p~ zjhAEMwll(I?-4v@{|UL^;;A3j-l}PK6a+lvUu{etMJ@;__V)^J`JJ*GfI)TEmWBTA zesAapprUqY5g({zD4;O+x|Rf)WKv3bC@6|k+(t!)fIzR6awsvv~3#$AskqzHKiMM+Wf^c{_npwO&Z>lsx(1Pk2Fv%Lw z{K@fHyK^uRH`tf3xJud;l;Wf#wzPrtm8x4&^JjHf`(ir5V+E!3$!|5Bpyn!KAq@3w z3PUffeA)JdY)nLx!>=dIEX^GTw>XQ1>Kak%mT$lBT9N-^C_#7M2-IL(H52t)W}Rh8)gl?~j1pNy>))Ol7!cJ0<&! zbE@#XbT}|bHT8T=#}de`YeVD98|bm+--+A9u1@C9_&gVf45JH7{Nu`8@CM&PLb2H6 zYU^VXi+b5BOqqqB+MF(p*$F1Atkp1gz!pL(f}OmH*2Gckoh0fRl3Q=gf)MhL?XXjx zMt5v0lVyf0w>Wea+ozaKrhc$eJI(|Te?sXjgwcYsM>R4ENn*4R2_NAu|Lf{ChG`n#shu5~jm$0)c)de4Kl~=Fbde(~-i5{cr$|w`x$J zYqqm+b)I+Z)-TxRbp0aQvXN)p%PaW1*Z9Pxd^Cc?T$9OzOlY{ef_}u#Ok42TY*Rzo zTrT=m>pg)tpHr7Ozo(y`^9$o`ShyU3JB@p9gXtLampR-({!$0S&Rtg@dI`ni5bZr( zwo4|3n~Ykcm?EJWw~EPSW`kriJ%(XAoS+L$qlIyG8n8rmckttxODjtn7{=g2MI$O&F6SrroH83;rd@@msJG^v*F<2t z;6l#NC9B_vza+Tceln)<`sbmHXaXr}*&l%*E(qJWmI4iNcmvRS`z-v-Lv|3Ps9TyJLXLM77&qAPlq+4k(@YQn2cQk z1$B!#h{WScLyoIdokw;2Up@~@{ynP9#4j8Hzz)?LZYu9YFHZhZtUyZf#n9Cr|)DJeMeGA~KX`EkND^w| z3ORDUf%V^#S>2Ed!?IStI*y8WMbsrI@oWk2f+M;996pUS?Am%z8ajYK+Zr0z)~ee4 z)c`$qtgKm`&+ORSQI0-cB?bQdvk0vkeYv`c(@ZyEzZJ`K*k~MNjS+ub>z+eyRxwqJ zKQparJOM^z{Id!BXIn@T#xGf6T=IA~-oc$FN@&rNlSUlX*%0qxsHG>W0A21~Tht;R z7UP5N=bLpE#mlDd3=lJyZ#ovnEqsVY)kVmzK|LD0ll4L~DthDz*9}b7;Tma5Wd$iD zebUw)`y^@0P~Vo`AHDF3KSj)2jz?f?*sL%e-OUPO$P2>!<*4Gy*$Y&rNm7|mtHlAz zsurrSdP!1EOy)gJW!q514H~X{c!d!!($dvUQ9;ytHB>fB&fU1hO>Pnk-#t$%l(=*l zN-&nHeb&5-C=2tPAKHxB0MIq0M#m#=Rr&rRjCUv6PfA-eBBcf{G$0((c^d!SVCnne zO<&9WJ@!*}pRam@+iHt)j8=>SU5{3KkU}49^`^O`E6$J~tFMI80eKMtl~Wec<=5Xn zE%)wC6yof18lOWM=S@$Nmw8Ex9OGNLFVrZ)k-Gq|ZcCNl z_Nta7Js02G+PPj5yesb4wLD2teHRl9zKL(%6McpgkG(0j;J)pR8NP9X7eMf^u6Ro$ z_YimCkeEBr1_j8$3lAGU3Jvw*(CVVz@Fh8wQSCIPz~cS7%hc29N*(yu^c(xxAY)p( z$6PgXmu+YV)Nb3g@6b6y_2#qq(cy7S){mwH))m<>Y23>#!lbbLErZ@}S1%g0P8Yye zj_^&OUDAp!U>5wX4+n`v^vtwOP(5>!gS(()xDor-)*&q69p!4)o{)n`*r~>-p`-v#=h3Nm3oK^HfmS$*o*{gCUM4}lpNXLMLM70R(+~_K4auMo(}G1 zC_+H7G;>x9Z^(p3iR2BNBK*$={ljdvC|tGRDpy|NhTq+ChAFzm#B7R9e zy`TMAf%A8|b2ULfR@z{FgBHi8y}hmp!s;md4)dta_Q^e!lttsKgvf|2an$Y-Bt;h3 z>uLahQI<`Y={eV4j882ugxhO+O8G$%%DzVkUWjC<<|xF=+ZIN#_$X8OooS><{hz*? z;(iHzn}5EFjS3?qY?Tgq_0W9$ua3r$G-32u0( z2}1>S1V$K^z=iO?Jd+coCw<(i*(?~vyi0 z(1^a)<<3UQDL6q#y8^clxCT9!HSf|ggoNM={Y1Hom52*MMHXqI-?pzf0lujKsly|R z1^Wwam|U;z(qY-)TO*|SU%x{l_Yn^0kg5k!d>KdWWd=3bn5OwMpH{U!div;8mqG3{Sh0TKN+uJ9Tc)99E#7#P<3X%Yu;O$S z3j4)qe}YfR)=(9GM}NqEpidkOYVIJ-Ky=ZOM2i!jKV*m135e+((PP$|{#CpJTPk|M z@?c5zQCD{7vT+Ax?VpL)2=^EJ~ z`^qrhN1tT~1sr}>TE6r&e(id*1f~35yZ1G^2+UC4ckWk*nKH`%%cGQpVe-wrxWoI_ zZz(Ik@yz#zLpdZ$=dR_qJ@0R-)q6Y*2KLb%{-Ovt;{vhaPci*=NS>y;ru&6R`0Vll z4{+xNfuaQcL&RpIKM&Az?~P;E;$^~{8CclW#)!?K(BEmi9h~Buv8(aBP;|C0!KFMe zSXB;ezoWoj2GCz$_-!-FI4MB%<4@`JCtxeW|NT**cvTgT=5mE^b>#ea=v*?~W`w&< zdoy6&Lut2(TiOQP!Ge+OoUjaB>g^{Kh`^B@$eEH*Fb$>W_A-B;J*km)ID#*9W z%9kS;2+zJ-12F&2s$Abjzr|4L5#j2E`D777#lkVgOb>Cb}{Jzbbpzk{rn>S0|SGqstB< zpbn+ZZelawN=kW`q9;(xW!&RoRE|^8EsVS%(U2mlq;~oX znl&2HO=a+005kD5gG6#*6xFJ{*5dDNh5Xi)ZY?Pd8`kTj0jEN!Jt8yr)3sKlyz{3Y zr*`|z+Ad1qJPt9ZROZPknqAQ-@MCMTtw{O%rxf5;5zmfYS1^PiBdRU3Z>^`YrgIxd z2iTn}4v!Qbvhbj~Q3c=(kcdZRCR9{AJ{+OH+B3T*eKcK^To2UbZZpdNkib;s<@+JI zN}|Q^(MEhbEPI&`e&3H-7aDj{Oz)XfBll>e4C0huVvlzd+h!2tF@^&WyK+VyyA}|b zsfA@~)ZW5rH#XTniMAn!>Xa+9rC@d~4Gny@m5#5*5WB09qg<~NR;g5NrX?UOWP%kYt zY%>BQkvfssNbI~*@D)8hxfJ%Oo+x|aeyz>+dhgQTyOU2Km~+2Fk!{oDa=hOrzX=`3 z7)%j44Jn|s948n)Xz8@>U#EfrzJ>@;f3QD42x_bvo?9l4Zt$IkIQxkrQMAlQkUWsv zbFM+Nal6%bZJ240kLu$mI6dt(BOSx|Nv;vqq(y7S347eFtVE!dkGqB*+-2K%Ql!2U z5+6UBi_Tvq-V-a%^@hJ7IOmN}*uHZKr&N>@^m^@M2h_lPXeIdMD!DT46jLC3RN8Yp zhKZsrLWRNdt|oDwZa|9_)i6rq!KNZ!cZn?{gXWsCn6Y(IAIuwd9IG7<5W~>_&18+7 z`Nn?eWo^4Wo#ey{yS?8IyxL6fww|4gp0=gp~+yxY<|vl=iz)5b<@4PI(p{)!$IK(#Xt|q*TbGS%r^>aSG$C<7?!R< z!^!sAqTh5y>th{ar7t2!HwmrPy`UGIJNe19MTg|VSm#MTx<;5{wOkX*baB8Epxb~CuPnZibav8 z=MWJySPj)cPADB>bjKjp%GL|VnhgYS9ETP_sK%$(vG$@$e~H+dSC|fo^cvl9M|4^W zxfg(7}MT4Bn2EYa4l07)|*^nA42TQ$|#;;6IM9ftc7|(bGXy|Yyld<7xuU57QHr>_M zYnTABLC0k8?T_~LFa+FE_R7e0)vgltqoW7Dji>mqXEe&6S_ZvVMK)Z4uie|6Svonr z=l(FxOZU3rXH$K|=}WPB;p5D8Eg3q!2{4K~^~gtY&Z`Pm^2a#^_Iyte-l>eVE~$CBc$cvB{tfaH z!rBVTk;yyZ#+BoUKG@D-saB}oL-puKvD`A(y)2sdEFpkpKvjB&>iwtT0@hVr>x|04R(2(*J>`dV zB82APwtW7XPpHKMwA)4*Jwgrzx(__vN)uNzvGR(T>?@t}%H-yU*P@LtqTuZRyV({c<(y`__T7%p<`O1yaYoQDhUIEG%wcmj+55XA3iQP)t)qW*(Ryr8UuTiK zfKQ8%(%_}hgy2|9&L7^#rW05{nXISia_$@oLm$QT^+!$&lAd+3=2!imb%VnBCrG)8 z&iYM(vo;~4oSW@qL4o$1q~b^JQ)54s`RYhkME3Ap&O4=uYkmjM;z-vA92A~ z1}oFVOj}A*dcK+gDD+oVUGQ%N5BmO|X0HH0LxAYt=gY788UK$>Zj%1>NuF1wKE_WM zRJbZ;#$U%u&xE4eV&C8FMU6be71pW8woxOO>YL+hpYy5vu=C4HX)&OjsGdY7U)tvO zz0`VQpLo+Xf10hn;~F>?2#4)3JroP7_Cl1hJ&4cJn% zWq?Kpv&JaQYm&Pp!)hOICAHuD9nRIDaT?C^O*LzjskgGe)G6lsKXF}*%Zi^~MpxDt zhb)>lF!zfl3GeSeuCVzgC-?UJMNf7*LDw5G1}MSTxhx$$wflu!z|*q}Z2KX1hKpux zuh^nEz^pMU`%QI0q z9U|W)Tq=>holv%2#ez4NSAw_d07;;QzuTrePwXcI=zhbKXKgU_^$F(?KpYEzYzoiy z-rf`Y&ZVpnl^gh%=c%@_OizjGmBM}wtzd^QFRu#Fpm^$H0jp`tk;yvB;BLm)mCE5QmJafgH_KY!Tm{H9&)#)DblweOhAZCX`7MI6r7knBu$vXJrdK>fWdJQN8^vk@!{LHW2E%~LuW8Q zguHrVr1L?*^7&#rdV6iLo%}skC{bFV$}bdP)f8x}R&l|P(=rVSD>(51q2S{F4;osHIS zuYHk9B9lHNcS($(B8wCyt~=Ycwb?@hKjaCVwn_C%HyJmgLB}K}G<)@S z9T)ls_Wt@c^?m9C-hHWdg4}t#?f#+nob@%#IAC|!&G%JtI&jiE9KnR*yetSeQ)-b9 z4G{7hnwvW(Z+JK2%dZS9m#Uw2vkCM>z713cy|o9dJ&xYcuiB%uiVkk`Lqkud-} zCz*rv#V!2WheTtP_;Joxa4DIFvZeSgf4w{V^M}yi_Lm<&N$5`8fBgJZ9$zF0?(uhN z@@g*g@0d96HS*;t7a|M2cUWG0kJo-0MC11@lD?IZsUn%d^c$)|dAb+H)eG0rEgmS)CoBOLToNd+#Zd@DjEBw7a5QP@_?tD^atLQRlFCw+Dj~%F*67M_rC&b1t zW{*!<$#evCi>1E;;U0b+AG*RL`jB3I-#VVRLTS{-$$uHn)+D`$*Cn%fsM@7K-|fME z1=VxC1k#wf5#7=r_mDR}Cd)vF*dn8L82|liWeN6McZa42X5;lO)Ue*E(6^_n*o&is z7Q@bp2_MsY6s>hw#-Z}}gz7ixiaDDrGxZ0~{@1wWO*Ze5z;PG4&iEuO9T>ci9UI?~ zb!umE3xR**k(>~&kUkyt%iVb9n6V7Ns&XaTZ-; zcQtBME3zBwEK1fQA{XfeZl>+LC1;Qx@a{gP;{%tUwNRTsLE(A*=MSi*#QyuA2cH&~ zdMSIYP8Ho6JJ6(IIH}LC?GPdmXa;@q@_lJ?V{PvY1?%g{Y9n+qv_#8AL?_90bdS{F z`U~XW7|y}+seX;!n*X`~MnTop(3`$OhfEDg%1omU(`IVWzHy*Q?LOHRkqT13!e zUo=x&O}s*~Sw3M{vDbbrirmqC9BAQXu%e6BAx5xy9gt3dDqHTBsmfo#+3uqUgHrk*A zkbdgk7KL>4D!Wra42Q4V{ZOCxSQD00OG}7XVVt*tsh+A)%!E+!oL%z5A^n@p4Z5M* zfRUWIk&K)0r*k{nzhK+!bvlWm&U=1gf5j9yMExH506%HUm7m4eZjtp*H2*w{9CeGY zw$7BNZ8YtlR$a0kxWzJk{|?jvQ!=l#4L!iNfS#VXD?QC@X1c~uz%vBUzIW{n9dWwp z0Py}E@6Kn@i)q*B4Gkyw8}A4vq4i)rL!Q7oU{hA3LcMmtdytRcO8!a1de9c79ESEN zw8*S>?q^hd_DH)LydC~la~jO5-oY}Vm4o}v%fxxlBk!4oy9N{gJJ#~?oKkS>1)>j) zY;#q62d(l`j*Zl!Gf6D=#boeZ<@!cA?griq@2uSLP#yTEC}qOoUiI%^XxWWa2x)-1Xb z0ACnK|)$gxk04(~(DToi-yQ0z+9D(T)``qxD$igaKN)Op;-#+K&kuXhI+(_5Ec zzpkjZA8)n4 z(XMz!x~(!#r8D-db9`}C>E|BeE{F~&MnjmPrr2Qt5s5)ZddJIam|_xy@5ORDPD#)@N!m-ll)c_eHYa`JIqiT|Ix z;!oNfqscby99ZOJfBZnP-q)%(f(B!`7Uyx&phLJ!4mHsBM^kRkdo%u)*4*IEXhDh& z^xh}51D|*jKab<;A!9#bo0WN zF?nmfUS7vod~m>O&O4hvOh;=$myvP*H@BW)EtTQ7F1@EugBdGh=Gpr&I1QN181e@+ zZT@clmepyr=*-{DKS7b^*m4Xn!@yO0WHmG~cL&lRYb)>lX~tX>ZX)2Ej8IO40r7E* zA`1nJk3{=tXw2;e3^kWOrNjwnOdWnbVBq_d)&`eQ{u4}&^t|zv&w$Ur_4{hHd98O5 zq|kMehw8N6Y+Pr11hnyB!%n3Vxf-3mh#nI|G0Q>+`GNyb!q6ta12ylKy3f$Kg?j7? z^e1A#<_z#XnhlrYo-Yw%F?**5WIw#0zzRq!3>gaqMfFy3?VarHcw4TuGJ_G5!((y` z6Gy9{$E)WuOHG;jY1452xUQ1>YwApsk6<(kR!2VP2gapLy!7v9`qufZi>2bhQ652# zV+updy^+YPqV$O~EBw~~RtM|jgWHe#+-7FBh+ks+xD%$na>ZfVHYiD6Fyf#Nszh@R zYXx=d;oNJMnh;zL5!KGCAkRxT#v^7})w^JmaX_!5VJI7LrQ)8WF1bsSfXZr8#aD&@ zUP<}a>7MyA`Ka+T5vH`jrCcICanIL zRp)wB1N1*G%%_h^MJ82r|!uGC=&;E1zjl#K6w~udwH1}?gd%=G%Glt1o&7pBuenrHz?_g z%l`XtVpQX-hqECO`lTslDmXqOx0wMGWKu-2!lAcsZl0 zvp2Bc3~X=h6+`9{S4|9nP(guJKq~4?^TH-Qi4Ewgv@dKnm3PDd84EXgDY%6XK45MG zlG3r*5eoytNrbIZH;A7+v=Nu~K`@MsDNM-+;|N&5eGiK0PwC71Dg#TsHb*M~Zu6Ff zLAmWY80kE&?vD~bE0NYs%_|qsH5B0&;};1^HKnIrWkgWVq6HgwabH#G{xr00w@WVG zg~?i1?k^Jl6i(kA;bl+tTfKs4qQPEWqNqGGZ_-|=X-JFTwlKpDeU33lN@cYmHo*QJ z!9{X9N9ft!1FL~csWK74oj_klna2LC!R1M~_zZ}9LM)R{d3%X?w)1IhTF=kKgX4RG zoGKu=H%`7!`o8)Z1b$(_wy%8d?cUR+)5CcFO(I(uLlZ@`vf*xt3pA}tFBG&+2Bv>x z^)xv}7o@b;I@00lUIt)Qxg&c6YUWLrU`o_Cl-eQCub<6H20E=My-K>dQ0}^=k+Ee- z!j7fRud0-pw%Qjp*=#xaL@&UMz+aGR?e+GjQ5BYCM0}cZ#X*K58I%MtLIKo zyDvluP%KkD`J-7LlP){@v|$P0TC3u$DEBvW8}~J>CY=G69)y6MHlmIa`~6h4$;+`o zaK5Prqv5Q;-PhHr>s=F{-bPX@Y{?6e<#<@5ex6Y@kK|Wc=mEv6aP*7v%Jd+#ruT*J z7~>GQ8y<=qBxCssc+=vTtU34y7UX+`pR3u0u=lQ0qC z{&}*Z9UC)}GQ0~IsF!%juKB00*36C_ul$)CrB5TBU6XV^>@v1a8}|=567rk1-j`%P zq865pe=)LxY-rJ&66D=-Rz2iX8=a_dt!H;o6VoqPJ>SW6>v7@+OXVm3>ngf|NrHcG zgvjmz4IZX@a^xPnjxrMIaEa{0C16u?HgW2b03S1aI)}tp{wR07NdZHDz1?rYQxRWW)RtPrPf$yghR*{< zF^%1vO`w@_)Hv)K9L4yokuYJ-jTZiF!4COPngqNcCaGgL06VXZ`?{Zedf+I1iZM)K zi(m@S5p4p_B>1b}z`AyY({;i>xdrVdn1pLw;s9|Bz!cUhA0~GOHkLL_=0}tOXjcX* z0)B?eRx=!)#1A!_!CwSikuY*+tEkAL?htmZ)EUHOY{WtDA>P>5h|(*`4)w;4Op@yu>&)s7d+NzCO!Yxy&fjfy@7;=$kV;G7{Z&{{e38%sCo$Xx96#FA(786f z$&#j`iTm>#sp2cqkEWAWthv*^d1-+VOT;c&;jQ3oSi(6;IChUYMvl?1PNDs^l*b=u zt#sGwq9<0wx6b%;wfG8gE}|F&)c7K#`6mzCrBnQz3P;@zF0}7Fm@Zz*F*gpnHe{Nq zV)do0AbO)d#f&3&sa@X`|`6_EA%uI{G;$#LMIRUJno3kXx zeuTKL)*lnB76zziYE5qYCbex>dR>8Vus?h@fhttT2bzdwl?Z*8{GcZjXP=y;9HFvj z@B87%X3^_R$~+pJ!OQ%aumf=-1 zYYSMPe16;>+(EK#51HR6o9cA>AcTHKS$=396(rlBz ziL;<}5Zla|wEoPk5&5sbk0Gp+8;w*Fg%|O;&xwK$p)siu?h#Y>wJr7Z`an#wI9iPq z+ZeJ=&yKr6Y5~x2_vBdSI|N|S(p0Xfx>|7D2Y>d0)!IV9GNc*ZLj%KpN!&T3AEp5AEPc7~SW3ubk$bnh4N z^WMLnSaXxwosNt-Hc4YWJoW&O@GIn2`cpXt(!q60Nx38)KyD>ZUa&v06Yb+-3=LVQ zE@gfgYHjK(G{+YKYCt#Rw6leLTR~8CoH*5KZq30viZl<;^XoMBdAWo0`Av>2cCxuw ztPZrG7Ps1h$qYq_JpZTztyS|gPR7MnhvAal@KJVpDA8OI5UC3Ob!UOfp8IG>&u>je z))G-Ke*i2uFmR4d9&e`t?Y*#jOS_%CAy}4BprYzmMU&w}3}Jl&#jVuC)5^{0f8&vU zZCh0dmIm)SYps&-1KBYccv~Z$<^q8jD+Ycb7VUl^50zOldJ)R~h{fV2 z^Xlt8eeK69_@ZdNqI)i*i0mDK^|ny4)%qdI>_{hD(Ro*T5avD> zwQUh6QsWdgLF8!W!jc%o)!^QYp&i`0m~hm~xHwtera1=MyEWlW!@`4`K1eht48pTG zL12&uC8=b=;niqq1LRdGO;10LqwJjjCfB=HyT`cA56yW3vTL7Hzg>g=E zQzAMRE=WL%1Li&Mic*qwp?cC~&Y7p^ah+u4Mz8yF#>ClE9nr-2h}t<|{j>m(xDVfl5-u z-lDj#Gc1$u=8m^97n`bxbf0{D=59`Y6|ZKFKc<>T1x0J= z{^|TrApmK^Rhs2B?JI zxUC5OVJ*U}e^`%jtew(QjlQv&-fvi(SI7e>7AOD_j?E2Ppt8pr7t3k^VHZK4-H##%gKk|RBI z!JTwcN}zBQZa(L6S>>4$@}?VZyroZMueCXK&M_&FcV`|QmUQ`NCH5GQYP~0c9Zd_5 zQ=zD*3=OOx+UV)?@&|dG2o11TNiHS4eD6DqM*>HF1~~JYJpiZzXQ7R4Q6hm|xRDsw zLzA=unXMqVGJ+*6%t>l{5it#D4ZWH$w5fg8FFV|v0r6br=bW8lH}A7K*E$a26;CaI z-y2t!0ev7{izd>S)NdE>AL0(|9FNThd;lr4Q_kY%+N>FAfD&eVo0$sB%!<=6g?%|osk1pBqx4WCSSEkdqzV~}G-M2kE zF&H|P4ZbT^Cb!q%maBHihG11-YgJ`ua$hf+bLH)P?tEzEykGK^bqBg-_WHvEf#k2~ zE_A*3Gng9O%^%?iEuKR5#eLKHF>VsjRft$Oae*1fl4MBU4r#pfPhL1^naq0Psmhq7 zSWK^}qIUSycpo`5SwYLTYx!wO=u7rZfd^K}->xq=9z)kQVB2o|X?Fj`>AwO~&8Bsb zgvJl>wl=J&Kh~&`$=->#saXWa87CR)wU8WXA2MeI?zxcfp8%TtXaX>88A&$z%$*Qr z1dy05Rh3HZ@9!zou87Vj@{j=+Be+`P7eb}Wso39z7(i(zh&Z}jrf?TFF&RAMZ7d)g+cQ6QoGUD_Ob8# z`fHokB;*twLD#pjL!YkeeBo3VuQM(1wml+Tf4oNAt}>`NXrW?P3lB4iH$4Xj>RY*t zZYDKTRBl(zk~}}XK}230*Qh(;(5}vs=yXW@;%H;gk~1k^er{c~IRcg|0)N)i)D)A- z6xL$(hP;}aWyg-sq{_ClyPIV*52OcqU{yB3`pO{4so+!s<~w%VDmhJ>LzteN^y48o zZZ{vgWM5Mcc|C*K*&u_mR#wZ^H`>lc z<}tS=VvJfzEJiKRG35?lKCBXpPj%=(lclY`x9;d#w#mq8Pcq&Hy98H5&3@ZntUTz1 zI_p+?X0GAQRQmEWex)>bKy{|$ zQ-6&y1ynQ+!+sV=qjM+Pved?&Oqs(XF@WP;nS!OqyhlLa9k7rhlAai^LI$>gqyGqQQV&u224=X&-Qe!Y=5l7ir~o*m}8?lL!((P_0b33tE-M#{{W7 zL?%PZ7Xt%yer2KN8_054JHUBcs?_Gxq012oE>gWHU5t$0yfW%2ywx@1s@yoEoK+WeWVW2p4sO(tlV+vD=6RrD3A&TZgMy^ z6*Xa^FdWNUvAnl=rNL$wiC@ouNI?%))tc9kt5OFdxJYX2_V%#8Y1RY%pWvb;f?|41 zCtK)$66BAk#sIS|&zJ`X+7O+a$WA7By>UpB&?&7+L0?rhH`&{fs`X8vGt{YQS6S?p zqvo1;$!kNK0RDQnIu6e30_REVV0Y}afSEroE(#wrg0#7yOexRjT(0LBAwh!%G(mC%MIps2Y8z8C)_dRjDKryoNX{&E>kZnuBYu} zA2J}4OfN4#XEruw5$!7LV&M5EAxm5#d~ZqbTS)I*fRjxh%-=VllU}y7-O9i?63eiJ zv~t<8?WEVa?)T>4FEm42$c6(=44m%f|0-T0d{PSGz?UPPauPDhI^vnB$l42P85@RWIM0WMoQbWrMQ=r%#;q6TUkl5& z+~3@7M^ymt<6`2nf-PY~7KE>B0wjk=)@{c#9c|Jn3~`=8sQ&9v3O!C?Bz_=KLL*M3 zB3cP?-A~Cs%f~4>ao<-md7TKXdl=$3=#9Q^LP2&^8XRn& z|0wQj^Dr(hRHKKiC;j1DKDLkc9Wu<6vdGIQNbLLeG3<{nEn##qv8`y5GGiW;`rh>W z;z|$OCf-;LDckTW*(JS<%KZBh0s~L~!S8TLgR=Ynb1H|io}Mf}8-ahblk#jA+cri$ zaVCEbn4SWAtrn&*z_S#0;q-`VTYNk6i?^@)Nyxh=pDi|4d1VYCDdd!bCw0YJ%Ty54QP!B7wb2tJ4NYatvV8+ z3Nk$7R1|32*)?^;R6Qel*o{9O{r{tFiTgX+elBxk^1k4(pG~!2*!QA#(I>fTq`&!Q z4D0QD8JbD6jtu^~L5~{10U-YNIVi8jD>rthW4noEwI!dSyj%8*4sK7|xje(HIyhf8 zO=jVj=*;w=z4ToD>>H1Vi;Wnvw~sv+;9wtqWx_?P4NQg?P|E)dQ4O>vINX`@(Ok0YWlcs*|Um%-j$sL?`gTMpU7D?$@$0Y+jZ}h zRoB7`;@12v4{?jDuS3|4Od99ndNq3ey4p5u?!uag{bTA(bM8x2z!==EbXB^zinY4L zKdr?kXZDuO>0JPhPt+KC__$^T0I@{`+HJ895t#cx2{e&|TqA>h0Z` zr%n}l7XcJq5fCNWkoj?rp0e%h;{t1p@)aOR@rD|NoEYaCBT zM=cBHFT#w6Z};yLs&l6BsoyZ4IuakM<VL1ETw#yg&CQmnKETT~UqLFdu<8AJc!$R3K!u%R-zU|nAjIo|bz)6rn z!5?eMfAG`#>oQL3NL}b9LPhrc2iribSXV)i@Cn&;`vI*(51N zb2TrgQBMl}m1CQ@(PN|1L$#r|B3_0I)q!71SN&6o!$^cg&qU4;jQjU8Z5cx1anili zLTWK%8dpk$T9P9B@%Dk@t=Xe3ycz@6j5Q)=u2frfy(({SsRB@&JVsu>?e>vrB6Q|@ zPZ|4mA6z4|{G4BiP0L2n)=aUYLiQ)F81q0P$h(8nV`?R238%A}d6HcrVFx_Op5-H*u=!kGj zEf%=y@zuh@qDf#BT&qjCG*rrgWB6l@#BMEPvdjRy$%wVt*o&}9efagoAvl5i27m?2 zwi(%aKs=%FsrPKq(oBI*u6%6hp;}jJyZM(Q zQLQ4sRb_zT35}C9sL(lQqG=XrDu*gtDRjP%cNju1N=ged6mK8d9Xnb`Hv01MLi8TA z?x}+H4{Qw_ZGDnd{A^{q2tqoJ27d0_@1V4Fs~cAP=%-A_r63+%Y{CyQ zLgQ_8+ZBWQGfA#r2UkMeT2ude{gKH78kbnNo`2ejL#?H47P+3NQhA+mkd`LHB{JEZ z-K=DnX;t#)3?Oqt?*Bzqhtq6 zKW|B~#422b?RBY~z|~cU^J*_CRfm#}pf1(N1Jy4!(Po!_@ zsLtj7^SioAHY(wMYpYu`lTgL5BdFcFQ}g(rEGaf8c-ow{4g>Wn*uY*E&Zy|g|V8C>b3#U2pFz;D$k5+42cW8m2B;otx4-z3}tG*Emy{5A8 z=oTx9b)T)R#*80)zggr-etY3G6n!4wZ)kjqL%I#aEffuZQaz6#U142sGUA*H=H=o* zulw!d`7&rry0>We^GP#^o^2}fh^HwD2S1B| z`;{dj#fHB<+)7i_^Pq~sGUqj&nf=5nv(g)E2%jtPWqCq#vryLwp(fTUiwI{cIDC*s zLYo}FiD3;^+*0cXLx8q|m^hJMid%`6P;q_A07^7)G3u`@bN^X=j-_(ACo+yDyOElX zxupwrJsHB;xbO=jiH?KL1~YgCm(rN!rcOZh|b+` zncty^{OuX>qT}L|Z3h|8l`{fP1A8L5-G5jQ-0*mw5mlH!u<*N}p+tqX%nM9a6DSyW zZl5BNb%1CM(^)*0;mGcR9Xf-n>-Y2t)y2%F7I>BEGjQO>9+LmuwpZ@mZE=Ub!LKQ9 zq?*80v;erF1xWQ^Hi&^vRopU85r5(WxOQ}nnH07=H7suJKC?fuCActAyqL4haMjD6 ziOe5C_g<|$6vG8?Or*EscF{uoK6-T#5O>lI%cQxyyX_+EZGEB_z-k;)AW_Kw1-kJp zi542&=xY-I|JUovBPj#`F}KZH7^KF(IcZ4jiUJ^C9fm^19QUi!;s!{cZAuZsS0ZOn zsd%fwPf`JmIy!wXDvwa%{b@Dq%R8Yqm>%-_7^F3p%x4e$)j{d-7S_fFDEAP9A32h~ z>IYkMMz|_`dqP9^MZsEFLEElULoG=kIDL#+FpAH z=GPy-+L5(42GUs|iDJVK&5h6mwMsCRn@OAuDGL)r&3xprJ`!YQX1I%29iC%JrEF~@ z)~t?6vcU41E^4pg_OMQXPEc4u(-C{;TMG`r*9X>)|M)ic_J8p$;O2k$7IYunkOV0C z(Ni37L}V&Z;;MPo%A*-l)vGMLhD{9Jk*qbwM!ZqF!~=*v$K^)QIo@xKY4yo>!uEg= zzp-5ti2r`7I914315`{oDqMyUrT#zU>9$1-`6Yhw6S1d=n*H zY-K`A8DV3$uYBn}>UZPk()vSepo1Elz0A= z>#z{If|w5rqrx6ocFAr(*HV*|hibaT)f9y8Ldv&Y{m!>j*#Dbv*%trt?S#FXWf~=y zVFfqII;@$ilT{F2WK$aD;%*Pz-nX?VghX1`CJ|-U{0|-Ji4}_i#;cO>Q`5EWUF}?k z``whf{^7i@sN+uI!ubLDpR&#rf^v3F`8Keg%lOj6c8?~HRn9ZToX}2iz?jE}u7}rp zSBXIqeT}n4B&f@#+3kJZ)3rRN0)Oi$^$LyA0$PxpnRJ?Q$T(+UPf;W))(nK4>G2i7 zxeC>kLZZLj&b%DLyc%23?Kp=kH1SP(ndz<*1MKkKzpweKN97GfphF*>Tcj3u6s#x) znKxBQ7&WeDYVM*&cSFVaa#p}0lSIzbp#BtJ=<4*)o5aM z48h*nMrtrqDIA|LjdMe;^(dnE4|pfzhJvWSWc9Z=zIj!m_4#phWise+-+CyMrl(2h z(Kw+<^Fr~fK9R+gr;USueVx2nUafF&U2j=yqW>%x4~e11is_-a1ICUW)%!;;ASVsb zq{QR6q3sVPDwAoL6FB$GQ{6=?oTFgikUwGk-x)4{zj^I$!_fYrg~E28@8Sc~!UPYq ztuwGg6t87PCl07Q*adiCh$DJlBq;C=yhHup6>hr(++#}kFUJ{$-I;ErgcOhK_VYt> zbJ&6FI6T4{8T|iK;YLloqZR5Z(Yn=$9O7$Upqi7?@|ZE#6}|6|q}sj+i{rV?coy4O zp=Rd&F|earVe}!yk(Tvthd_lS;O0K@)Y$*XP~xt>0qTTFh9E;doOXpqbo`*D@i-~h4s7vG% zQfL*qy&`?CBp@^U6EKh{FbMoNW#MS`Y?Ml1pv@NFLN3MNjCPy;x{K!(TTh_kX}OQ) zUwwP{Uf=$>rtiUm3nDkgo(PfJn*khb1!>_7%ol~9SmQ8tE?m$v+ot(Y<|dUd?5)(E zoQiG8G$D~hI4%eB1$h+-EtUChAe4Ia27p2awVQZ zUZeSDD$1B zLJV9whi#vqq!@}vGu}?yAMSn(YoDBKZ_PU~+(rQx{JwmCKl$p0x$w6jxY#~ikRN5W z=o^8dOMbCIHF;#vXhc>X|0lN!LMlc8*`?n;96X6IUxy7odn-!JC&vj+squG?_p|6~xXflVk zzDMctFioJpI0)-ix7S)DM7!j9uq~7-cu19TB_Ql+xcQzSy>9k) z?WnjrzSHgIQT=n4_0?ji{#nFD7P~vQq|jexH1b7R`jl2e3N@Yxw^9pkuww(Fn)FFD z5`UE{?K|D}HMhnlV?XYX{IG3Y=8cF+2X4S4oSSvKjr~BQ7c4|8Eyk<2AVS#$1#Gx> zJassOF4`@0c1aCd%}`Odcmy1~hO9vUg4+fp2CDWAgZ-8v1&Jkmlo9K1RGLvCU-Iq* z+m4g_{mg&Cm6^*;(n9DLAs_C_!2_$#$;CJ6?He!quvXPB`S7e|M!it;w_Brh6$J1q zn6u4b*qB>bE7$}rra}_~2D^eIsg^9ba%9YA9oj3C7mYf-+7JAR`eya{ezT$J7YL#Dg4?KG@w=FUu>d?;>!9e6FG=;9PC$s#HOF}!TNCruTpileT!Hv- ztDD-mmQ6sCA6#wa;m_%vV94t2*p-You{Hub(ps#Z!T16*lo0|+RGP0}+2i9)T4jpn zTTu87Sv>cd-8eIz5`RWh zQL@PSU2i+0`Ic1Xm=fmx=`H5_!j=E@c2>P%CwlJ>UdW_UqBrpKJKi3os+q5ove%#m zh=`yE5Mxi&&uBB{p8*%g;t6IJywLo=H1N&V^=jo!V!_jgx?>;0Qa1}xn(zYgn!sSy#AICbDOhl4UXIX)7!45cfD2XIYenF{2#qN z;YGMM^*8H|D)w}{uH|U5_adx^w88txj5tk}nK&_wVcXL5Cau-h`Y0KQ_HH13nAnWg zB*imNb9JxG0ME#jc_K#6JuS1tme&&@6rIjF{N9XjBkAcyBqF77eq`2)EG;kXVps*! zcF&<>3})vXcs}fIWZ6|sx}JKW-1HiJ{|C6hwObzFe}Joa*Fm3WeYXhjdUkjbxXBn| zwI^7_{@ucFyAbsLTFELouM)&*6*9E1l!y6V+gcpy0Pk%4Jv7>31vN$FLgf72Z%F#J z`8KT`7YvUZ;1s!3H;F>L3<_aKib-F>+oLyJj=ns%HqxlDURCkEZZYE<9EGjW(-9pw z2kD+;X%6$=Mjl#wI@~7hMBsL|LN~NeS%N0!_+pGBeaEk~1xRAgu(>WIy?3&6@!v6pG7HI4+AuBVf z>|olBZzXu~(HElTGRqSLFe0U>%7pLzKgd`G0Sp#tGH@a1ata_n6{; z#uzobC)p;iCzBY1p4~D1*?*6;G%az*Ya`9DbTNuA@Hgi0A|yB)M&{}hJ3!AYbQTwj z`=u%qa#S-nd#KmYY=Euk+9aT1Q%N?|1gqj}Z-hd z_I{&*x7u;r=2-ovi@C;k+lfD&MQ4Yx%SX%%C#2set%oOATB*oA%XWuR2wZA|KNrVF zKCGPN&@z$LoDLs{&2)7;0QBThb>O|(u+y90SOW*9 z(Q|v1nkE{-S=w{!?I>URkdeeA*QVo8VFJ`m)ycI&T?5NG(U`|8)_x(ALuC&`tzy$w zQd=N-9}I@5xd_idWFO@TmOKISYobsYf7&qDj=IbjgDo2*;MBv=Ga1g@8FfE*TgY_J zMba&Jzvs4=ZKe*{1pnzR7=P+hwY7Sj7)>_{sn(2fF@S>i#Pf36J;tC)8rBVDMmI7N zZ#8;j`SmWM=T+{P!G>w@2H3}I_^(i!?EBTjzE{QdO!vvZ;`aA@ar2ebefhy!8#{7|?x3g3EVHk1&&4<Y^Tcmp^~P^0DwVFck|l-guTDc+(K@^plDhEmBYUx){yDz{j0X zD9zd+v7M-@!`HVTVyV7S`jikTGEvzr-5^rETE%C0DyUOA2c2AaJ_^IF#~}09@qnTa z!f%z5Ex$pT_Jpmg7Phe)Dd)qalVkP7v5>s^tuF8D z!pXi&!`tvzug5bt-c!p%jd+X7MaPZO52~*|`THy95p%Cxn5#~E@2~I*-u*TyYeAF3 z$x3Cd5WPlvN}k}u?+J=eU&Y#NQTqQSw*#44DqzW_wTp!gf_;QUoC0$w1T}o%Uy1kR z_B8#29`aJq_|GI|1dV^q?Xc~8bBnkb4PJewkCtG{5(V z{#SA<4I4xFea8@e?<^d%*JNSVX)3lH1_> zvFf0xhKi{LPQtEfIPWeP`y3P%t@|5s^sGYpO*#srCblcpQjS5_0Nu|V4To^EDh#j{ z3M+!}vf}OUfGdsu4!AgAI>V>C_?j0bhqX~5zhIVox{Jx1-B+KOVmnXZuDul#@ot48BU!z6fjkaN__KAM*rDEicnkEmir69pS-%G1di z&7SSJxWghG8h=r`-+G8GjGN)g2ayD3{!b7mDSlCG4-_mq=mAoAcp`P~ro+@l3;0dw zSwE#Yfy7_i+&f!7ysiYFsv%`)y!lF^h3flpcpWel2CS4}t8YkWj*lEY!=RGDc`iesv*9<{u{W`RYEH2!+FzW_oE zMa1Ska3JaJ0ZJI4f3I$x->X};_v#ks>+02CS$Q*_NDHrMv$Y_fn4L5lPTUg#$`H*X z|33!7Y4bkw4%NJ;+4BxU@s&@7Wtu7RZ+$cm<}{^E-Rpxvy(cTDZGFAj#cuBpH7wWO zqNmQY#?Rtc^6~A-sc5En-pkv((SPMFP?fJo&X_J~jxhb7;bwV`_@|?e7$69Y7$q3zAr6qC*`Eh&U$k3TX~-oHJO6k!z@;m`oM*zz#Kh<< zf{L&G)tH%izs;DfCsbVd5|S3R5qW=BYKUfM_io|!HJA&*xkkh-r34`~n^kP!72nGw z*oX2Blm>ZK2QDP?3mpE3xGUkfBsD~LrLfTC4Lz@QMvVn{PVd`@WR?!1+66nJyo24| zzW25XG2h&=&gxsRzem%Hjfe8;JG7Jq?;VT*zAT;zy#4nnvT{Ug1UI zTs981no@~j1LNJ#gQV{@8ymaz7EXeRK#T8*9OwXaB zNOQ%ds8zGzf<8KH`z!y8Z>f7`Q4_s_*f%w{#FpGRVZmgfkAcj)re|L-#s?p*K79yQ%5wk6;mNh!OJ+afmCYyEVd)XH)u&X8po7 z4Y$zx$VXH;VsgKjGCfVAsa-53k$HF=`SA)gzUIK*40T(BXa2q-eYuVDgQu3FGcHq1 z{fSrPsCxbI`mQueFNJ48QYGJ`x`p?ve#xW_dA7FX_Q38p-RT`ZQX$oEt!U03!1c|i z|I^^&^)AfS*UXnC&m{b#TpNjhlzW=AV=n`x{~zT-`JF^{Afpai;}`J)rqKA;uF6Qk z57hOL|0ox8w~2A^opO6@Wy)f)8OF1gNkzp`%?^zrq0Tl`>#%U2&*6#eTM=ylMXfsA z1Ka64(Yl+3oX~5q?IaH82#f7f-P2whIWnU$Tcu707GK9IPXm0%-3d)e-Q4coaX!zs z!;-%zxaYrS7cUyQ1V>@6Xk-awCCZB$0*V6~*&_qgMC;4cXuP6v>O5ijE~2E&x-*fx z*`~I)#Lwjv^ULVaQZb9DNeSFl^nTu6vd?($1ipnh_6V_kd{AE2w{U-zR=pjUUGc)c zeZ;tKcYQ52+;3v*t?I8{IM<&#wF}8Vi?~#l)^lcDaS7mLfUSb&gmz9OOu9^s!jf0s zDI~Ya?=L}pvVmSNhqV_%Mu!MWZ2bym5RZhmsPVcH3y{41m0d1i!W=|pN!-9_1C}*b zC*jZjQE>D4*pK&%ix?2CD>CwkNY2b=p5r#STsKmlZaMJ}znL^*p(W#!0{~yVpCoUZ4 z{F+sf?cT&BCUOy>yDnFS{?pKtgMf4YH0Tbv$?W8mnD9RcI1`C`Sq`=Xd%s^IgJG-J1e)18j*D zfeU>2^XUo0E?IiS1HVF|FDkH%pBolT@i=Ibj0r=;w%T7YD#=hN8Sd#8a+0&4p8fdh)YXd2+8jGTvNnMrxN0UUMJVu0Xhr{DV&|TeY(T1S>W1 z4bruawW9;d5#QOz=xs!4g2MC{PX@^bQ!3TRM#0cjR5Zz%;iyxgJW)EB0KXbaWh)_r z)SKcw)W3F5>@lZk3y^Tw9K&Ux%XjF3-Z4DH92!|rgU8mWyDTjWZXbLHjxeW`Lxc-y z_$LA>nte$F0rnn*c->lf4gP}0%<`qOfaCTjZkIl)Zm6$6z1~zF7qS1*Z(r+Q&Ty=@wY9{TRXz{MJwMPw8(r?uQ;T*QK$** zrHOza4KV&DATwme(dUn7BMDAp8<=1Fm3_3@(YD~dUAxWH{xxf(cu2zrOr|-~?){{) zp?^8i1;5F?*)Ec_`ut_-QvNvjT?Dn^m})wlzi~hc5pbFSgH#4ylghg|N@o!ObRlhk(}dO( zRC0Z|ROUNux;x=oF*G&x#|dM-u{BEq+ZSBy<8MXZ+9(|acVn=00mtNz0P?~Z@lw%C z--JKnAL$si8KYc790fF^hOsNDX8?&dR+GqXS%^;>>+K{SF0Km-XOgcTQluwO13HXr zjr9d~NCG_~^{yDXa+Z$5ol7sw_Nr!&rlf4HeLOX&hIiAFvarbAc5dGS{wgaV@O@Gj z9&NTH3dWtXhB^7F6EHxzC4b+l!(SduQ>Z>(U+8sxM)I&M*^MbIoWrM=_fz>6rrc?C zliqSCxSzP*jUd*64&r!vm%(zoX@W5v&62K>uyxWg_0-*{#OLo|B{4ZfY3OZqpZ`Vk z&M<+azL`*Q@H*5{*{3S)^7O+SC~O~3uf6GI;-_FV%gc$KH^3b1S6@@zm;PFO=7VkL zn_Jj|!CD$18!>j3!OR%E6ZaK^-V?h9sL42BVW9sJ3x;+(MV7CedhZvFTp=J^j*U=@ zWmBH45b!r}{9t94SVq&l*ba)?*MhZx3Mu_ zQ~18Mw;BfiF%-gdAY?~xbV$6i>{fT=-tXC5t~cijPuk1I#VvZn_i6T1l*L{|o) zj^cGV*yZB$^a?xIXCp1!KZ@l7;-K`0d1F!nH)D~bl@yti920>)W9rq8CEC*5XEF%9 z=-!bhp;f`vVE{WAKwu)+f-H-#I}GAg44V$fOb~WwaAho(y&gPlVjou3=XJP$6#o1x zt!d{E^XJ8&w0+-`-(MsBlM(m>z-jw*gufi1ey4@%&8!hFJ1 zz@qFmZ~bJ@0N`?OtQ##$CHC4DR_TG&9TOoznHvG^`bk6xpyS1m;m3g|nWA^$Ktnw>nLiRJuX#j*y_@}@V z2S$JB&;YZR(PRi==wV9&=VHM)+?gZ=nA)nDamzgch+*{!n6VvBX3#LTBP1Imr33Xo z>TY7lV1dBqzp=$@HGPbPhTcD~?fCAV@Z<{9FTBkEe%Se++j$=Wukoetd;q@w>qza5 zZ@&Xz|8u1E7s}a7YQCC!&k>=H;gQrnFDfpd%kmQ}XUB_x6HTDS&7)x5 z3t(0Ns6s6h%DOs$hG4*s304X0wN?(<%mA)gL==;;bC!*+Wv-N#B?96ZRlmGY@)!I2 z+wm!Rp1c9r%mT0nz=ZY5(D>bHW3JfB!d|j<7qot(forOdN6FJOuukMb-ZE?igU|K` zz$b2_HWxs&8CW_b^`TC|azc3#aSP~ds!fH09IrN?!r1!E*N;O~U^S4(T`>=(Tfwuj z{w%m`mh(`$isidd0oJY9TL67w;xl!2tYJit4IoUl{Zz`+78EC!z6 z3Ug7SFUK3O4ncSqws{$yCA^xi$a~7N+r9{e`E?zA0k}XaWhku&^fF>fVE6^F>=q7^ zV!efP)IpzK_kknGl7Xz_0g}?3tYJ}e0T^aC0vh!+a4a~G-OW#pPq9uqPQ4IojI2lo zWYzE&@g`uAUEjp!N32D9RQ{$qDg-z_#yLbTU^XyRg4}RiO4Mz_eJpbYrSv0BNM)9-Jq>@~&I}=t})R;s{G$T*$Hu9Gp3k!k1N%Gfw}fIQ~a#Yc$uPm8w%?*EO?fp4x~--LYs)wJ{{ z(eL{9V(-lec>Vce?TsinUyl9OaC8VejEPs9VGyFjYYOQcjR0{@Te2EAFz4B z_@+_}=CgwgFUg86RegX|ULs<>zXESnQH6mb0t*g&jOl<8fxow|4Tnv@N`|$M41}1Z zT1q>OA2%pu1!1BSK7-`}s0_>4hU*&m-m2{GFjx__U`^3!FlUlmEG!H=^o@NF0g7e6 z&TIN@7rgJ&Jnru{+k>HUe#G-%0hjgrE%yY-oL|}$4~NYUk=e~iFBXJOd$t(8O9p!e zql5vsHp}8YYBusv>9ud0fY5oDZifHZ6GsqB7Gs3~9^!zASa-E!KNCx{>`my+@WvQ6 zfCxtHL1A5uh-YtAWBA1dbhby#@~e+eVfA<&iX~sYvxRTVFrrJGX|tozv(&t~)6IwN z(JZe~TMoP%35=%ATR_FJ$6!<$#4+OBY%Y}2HXI)l+o~1M3lNsUc5~z4WAV2UX}8j#}chI6eJ z+uroxr{#dEts8G<7_~80-cEbnXIQBjq|2aPCLFN1(KUpwkJ}+UUf6LLD~e%>V>46` zfMv8>;f6XOW6$*7XY4v9j?Mcg0sZt$*XA0mwOg*D(Bb$ob-XuSCulPk4NwZN3~a z4XGyjgJ9@v_e7#yVq+0F*iE7|0j*xxkt*0b6XvfahN=UEby`a;44?qzPTIRx0Tx@Z zKwhwCVSX$DBy-Rrwc?*?u-%~dJn(wQ&(!3iLS+7H4~-XsZ!5M!?T#JAJT22OVa-6G zp)1((0JgogEC!A@MjUi(MQj(~$LVu!qthnu#j6KcLI|QH*ipeI+}`70U+r0oHlR;z zW5Yi01uUHdsMu*q%VmN|mU|k%A0+J5L}8 zY+Gr%1;nA$-T-kicT6?I^e)Ar1-lABM*ks6I}mi-X+&mq#M>z}@~kVAa@lX@28SQA zB6%vvfX0lOu)xE)vF@@mZw1=6h8Z#-Ziv|OP5s;oFe`nWfq~hDK@&B2T1m+65>PR? z41Kl*W)}Z%*_6R+A$-4NXN=+!_DEGTxpOa0^$jq6}Gc>COtwc*pD-p(g7})f{vsL3X4IMFdIAgBm(K47ULEc7H^CA_XSeE zE4i=sv#!X5jm;wP0DgdDT5dph%u!2BVAmZ}2^rW?Z$*YTU3d~;^y?toT$LdgH>VF! z{^YVsouRohoc*H#iDhCEA!D`m0?PwT+e)wzWn71w<@}lz@Fk!OR&B^^tZ<#JYKF~Y zoQE?j6bC@51c)8*khcb~WwMDQGs^@dgWXVByjn;A^Q|(+xVIJxIP|s+1&%d4ONxyF z%Lw{BBRew7P#(0P)R&2C?>~6>S*ZB~nalmFozPzcrOTt<@d`Noav8(-7v?uB_qv@v$IHvm$fQB zPh9eA?wWtHwBq0R1o`ed`E6kwKW=UM7SR3u1?6uHYR<2CH*IhMuid;OEd`(l;F^SP z!sK+}4QLl^WS}BldkcFVu@w#-K45rF)~&L{USPPX#ElOF4K@=2+Jm`b1v`Nmi>3Lf zED^l{cd;jct7LX|x*2*=#yS7>66c4Z9U1!uzrl`D>n-g7{JilCP*&4ibTK>_TbNZ? zSSyRYZj&3Et|S-(US0qpw;d*+UTq-4fYkW-1huu+=}2m9(h6P=8X|ZIwr^!apt{Yc z{5hNDJMe9Ktdi~8-5 zDcbQ07|ss*6iW6nv57$AGw{La101Tt#$l`NDYU94#>a`*VZ4;kbZaL z{G5P~`nb2e0*-%wm-wFJr5`9ensWxAf<5;*7d=g$JM8FMOq{@<*lJiWVcJwxvs}D* z^jV4-L#tS!6f5~V-A1^W)zIObh!ZK z?QwJc0?T1Um(_-!;jk^RGLd1yDNWkY6}S4HIN@MvYJ-Vl?1uxIE3oWj8v{l~4n_qO zFr%IwcC@hD8!rb!sJm|_io1>8oEJh?AusiSGby)))Al+^us?RC(mYov4und9$uY7P z<8a=D15UCeQPQS9Sd)nUK*8x3TV`1Ct>uE@)M1}1SQZ%JxPwpnZHa&r&!gECBTf@a z$7vOIQXIP#^en-6ml2@v9L6Ou|3uN$KXn8C@s5}mFSy@^*X?yrcm-yE`I_{1hho2S zJ`6JP2&4#@&IW`YB{kl!#^NSEZ)_@1UbNI}Zx4^LsT|BHn^B83aEDj%2OK z%t}Nv0=Vx1Y{^PL0A2?_wNH|D085;R-a7=6MynGqim+Lkb?wWn4qjB2lx={>6DCh^$iR>@yza8;mCeVm z+*=x@*ETWJ4oDyk0!R@3VwNOt(LIJ;25SLN!1uHigKncpWdv#_Xke=^2e=24W*LgO#Qqm?SKa!ne?E^UlkP$BFT3k{T&LsASq z06BM{qdsASSZ7okAOS|N1^ZUnpaC4pEQ~%Y5p=YK!y6W^3!}gm&VUI8T48^P zaD7pJ-$eZ+xPIT3?NnlZ0r-Bm+D}d9Q_!Dj7G&G&uRH$0Qc@V zmpdbL#j(UKKz8_Vr=NV?tImAyWccp>89j za&Byh-U4WFxK0bOt6(zftHT_|)NKF&*M(Co(LoGy1cE-;A_;UHWP@w4X1oQ{glPq} zm~#hM&z2cXStDS#Ed@I%gPB^%ePIEtvUo+s+wnU^ou7nuKbR>zb)PSwaQV@8I2E8z z1?W#&0lGhSPuz-N<((3aX&=xmjx$DbWa}f>7=-m;Q)O>bFfknT-f$>NlG+vvBI;ln z+_33}l-x?4Fp&T-W|3uVW5SVByE7tb^Qxr)6>Gs6KS4Ii#JUea2X|^g-#bb!yovAo zba+4IqSs58bf<9iDIEPf3P+dMu02}2-BuOmUnaJ5hPX2q4O3cMXT3g{FM&Z8SkF>c zQP{3bmlw|HT;}a^rx~vgI%d5^CT!p>8@w}C(U#8&ju8Yx67OFUry}fw0ZS`S6uVPG z`bog~!y3s`W%@3Ve(65#)SEu_rmx`iXQ?+m9=$hiS@Qt*iLJz)wSRcs?$CK~eho-v zw7wbR1Bl{^6Vh*G1GO-tYk@uCBs6e9<|SdIGtF>>CHEG1Prh~1d%(;l zECUAs4_NBj=AFvZZ@zK=m9$d1It4 z+n7)(Xr3kox>-KPXe=nxgReyNz>Iv;atm2v0O^vLf!P@eZwhc;#%|2kG6pzh;G&A* zGG;YHt$JJEvEj7EP^G98403jpz3$Yxe#JfbRqD+9K2hFhDePYhkUmARPf_e&EsFh7 z!l&ni=d!Y=UiUkQ7(bP}Pv!29P`UdP#*@G19{ne)Q@!tl=cAPQenc?( zDfoQ~em|k$_lF8qf8v$=r?kJPI`}(^b3b*$Po40OQz!gWM#2Bo?f$1cnLcDu@kfQw zpYr0Ty!dm=i+{KP``_s(_>>0w)FOY!(fOw;`Ke0&F{_e)+SvUsIk&%7pBx{-f%RYi z_|O0TpTB%GGJpiT{O^A*{cQ`Ge+m86e@gNcG(QE+pH|SkzJ9IU;+N=30SehTULj9O z8+g2U$t_}0Fh+DhJ??|mdoybvL8%c3H7s+hYcp=Bf~%z2CeG*_LkHn>HVIX*$z}t` z7};EEf^T6B($hdERK(dareE2%_zK(hyu#)m!6cpv=zoFR?P`0RO6aE&`oBQ*$FGDw zAHNqk>lRs>St8?f=9oB@v1t3iVuqd=WuyZK07Hpcz!aFIV-iUe3md?M>C9n4XhVyv zKIyo~7)NE%wzVAU+xRxjC3u%G5V`{`IM@}8p;rKicGZY3#QR6e&y)fF2#3YHD4qUC z6y~qu=~F`elu&#3;-y;ADW z!PlSFhMt=17vOu`+drrF`l-GCNo%j~=j;uhK`UxV3gA5%=)Xik4<@9MnTM7`Y)+4E zE;vPZ6tG0_3K+V&0aezh%6t15%c^N~gJ4({LOP}wasIPp17mw9P95;Lg(W^DtXg(Z zD|7P%(|a}8@0>xuR>|xm94qgrSo_rl#9L*u1+%T4H7>%mHN?D?Sy}rtB$=&(9)Wu})(DP$B~`ptR2Gn@*m->q zQ{NecG$L!9jfiK$7K|oxuXy`&p!%_{r^@?X=zeuqc&fdhYVTJ7{qTjDG0 z33ZGlM`&0&a7rivRECa^)|V{_c!}f8T~f8J4LXN^6s*>mSqKjBT){Z8A0RPdnVX&B zsz4icftd-$3_^haUvZ)}EYmTy+)9&{vaoILRegW!t@=54-f4OGd)J_+O#CSm|GUe? zub)|yx2q^vQ5@0?zQjt@S{RG8q1G{1=@2Gk_d}hjfowqo#`4KUnQy!@mLBWB*#b2g zpmSJ83UD!4#&YsbWVNK=1Cf5s#q?pxWImDg$glu24&i>UT>Njkpg-pL)Rlh|CAfEE zdFsob`tql~{GX1g5}&zeZbdJB+rTNhpe@D{MW!AYujMBoM+YVVR%jDiiGe{41y*`KJ{ADTV*gQurS*c>h_f;F#xAJO8~${+}B9r-uGV zsGt8 z?f*Dc`#*Iy!%ulI&XM-%%KSe%72=fpKjr?PTkikECQAHHXUMVir$4}NA~OH3EQ`}8 z;PeUjkbMG94#wB2+CM%iSO4$+_0VCo$eIqi2H3@_@;C$_gF1uMW(9}GWUZ_QlfUa) z3A8+dU4w55;Q-_A73pCdVLu$}iI>~;R?2|axB$6WS{*w} zOj5_z(Fj;Idv91<49LKXGrf^tlX?Euhb_?mm)MnW;#XJ@`DpG(paBy5t}VflSgH5H z4~T?K{Wu0CgVl2IFS`TZN?fnJK6+X9(@BbSCdKaqS#=}4iE?6GwT4! z06=0m$c1zImb-Yg_7|;vz3O7k>J3UFEcbDX^#tCRUYs?^ShWwd0J?>}fUpgt4#Vq; z9S=#pIm&b|864Sp zP0lO;-eA_LEa3}vSY$I4nYL3B3Jj71Er+mJNe44$hHTZgBfdU1Sh&m_b{^p0iq8b_ zcGq0XR^D7f*ai|D#+^n-_ej}KUSA$A_nx?1`+9c1{qo`L^lQ%7f4X1Mk?iZZVgJ_& zbY%Pt4%y=$C;XA{qq*ij_Td*fsbF|4&4Ss{W!*frGIN~5O1hfp%ci%6*W|HgMyN?@ zSy*wZ0d|3t2H6B--B{*)WQ!(4Cw&L*AwV{)%@KDC-d15DEu5~2K|;*%&NhF{NpBS% zj&^^EyOQ6mB+Mi&w!OJ^=5|DlsY6bKEl@|Ev3nmI?}j|+x}y6cZOJUSR;D?F-Bf$u zO8;Gqm9gF4y5hz3`**s2Y*jXZRdB8~BhVG-Z@CQ9*m6#vU$c!2@=z#cLxTlOiAk=j zmEjskW|~k3=e3$7msp0awV*b7>vqIIu+R4-&ssexaIc5RmII@(1`yD)7Vh#CvN^VP z@K~*nP`YMr`IrXmMlNApaon%TQ*7WK>ZUmIssqND>0JY(gB9*E z!1T7pja{wXT3Qy5!j?uh8x}x^5b(w^r-CgfNZ)fC)3wvb?>o9cwK=ts+0MDn88b+B zz0;xb9vA*DCg-r+_r!ARe5ncG*`Ig3mM=DbJW_k5=kkw0sw2O*dN2JivOCgytq1e$ z*$c+VN|j+UwPUlq0()5lY-nWlgzap7$o}1X$Gtd5V_pXiB-I>hV|kb$Q(3mkfmJt# zR4VgIihBeCw7tOka7F>`6!r?(kt4?ZSQ=1ggnHkg;Q`aee6>#ouT zx^w0WSy7JAim%KnqO7t3;^(!ZdU>HVKXsnS&9jqumMXXht9N*DXJqhGxlst zC2ST$UA+)|I(R?h9qqEH^oqyYUo*Y90m{S73!(r418*BErqzJtV`*b3<1>Nzs!Uc! zUyYHPyS7!Z%~s}p4_+(;_ZHb`F0Ukgf)|2SU`cHHx7!3Ai{yzQf)?7a06M9l3E3|T zWq(tN?3_41U~y*B8nb>pW75FkQaf9mtjffa)dL=XYlGAo3XLsRx|G^?4j^v4Q3(>J zV$N}O8;q|7BZn;FtyJ&un00Mnem4KEEOsDe^TrOA+D2va;homfPx5FU^7pREU;pM{ zJ(oBScXR$yN9ZHnSGqd?bUYn7KgHcCe}(`@$`5yW9$WFNBo?FH9z26%=3#ix9oDs^O%Zz{L z`poAvdJHKZ>g){+b_6|6bAa1LH+P1r*tL+Kn^GnD93WdDOxT;91&kXrgA-_VNua;c zSi}u`S$rf=VrBINmd>w0$90G-t9%m>_Dc@Y zepZ zWl%{I=mg+YG_y`h(^c@YrFpE70AL$9$r!B^n@I|AZM6b|F(k__U-}*aOF|$CeB{C{ z8jtQSxFW_2B?VA{l|c1+_STHybi>&1q=WDSD+D&9&7){pxp~soHb6j|Nm(8wB#?b) z2YLbHV4JEO>cGNq=_f?DAS8It*bC3(X za4EO&oMm>+Zj~i-!25?vfL7(wH7e)ixzF$N>W;Z54=kYvgNlFM!Vq$HUYxlFaQ70_ zrnU|kZ%`xa>q3r9&t|zPAaiUfCi}u7gR{dXR`I)1-vf7tj=zWh2Lx6so4-P zL0H}E%G%FzjviY0L1W&I*>`G)+4Q>Wp|$O`+#*wGx`y3SdJKV9TlxaWXF57kKGPQFmJuD7YM`n{$5Mg{*@%bgfn(@MZ91Y7M#+E?1ge|mFEu~C)$u_j8 z`Ia+^$4V}~_t?QY=yz+Hu*bo-dmoHpZCFIBn8mtmvY&~K0vM$z8yJ3jW@Bdy3mOXmZArFki8>+0_=hn*|$mGB#O^ ziEjHg<>*N9XMC!EPWm}Ae5+se?BcuRv+ohtSPC54G5f6)4ThWXw6c|*<}eJASTUg) zXDuV;Tr-=b;;dqkvsM?IE&=fN+yG)-DugguRT7wJti9~kmPi=_x>&$<>>DoLBdcFD z)mw7(cb`};cUI{PnMF1`NCMF3$i2aWVB!K|z#K)B#Uh@Kb#IH7KEoQjm)NuiohG3h zyM(A$ynHSnm5w;}e%)+=3t*c%ro&*rNgukhr-Qaon(j;gs-9EeHAKQOaEx|sgTk<1 zG_xNRJ)%+ts_ec!GRJ#kKVizNXe+`JL}Bzj*{6O>8!ffUcDTZQI1OMi=$68|QW%LR zP=~HzvLrIr3g&J}z#{0{z4Wo>a}vEWj@APt1-uT?c#TjB`;^t1N*gwXw>o&c+sYB2 zZrD`H1kzE`WM47wcvgk3A#}{oa)>f^z;ha?+=|sCj%LvRG~oZ81nXe3r71||fC%$d zDWUiZLiiiHf*l_Do_J*c?i4;3Mh|zs+L7^ZbHL{B5y_GEQ=G8&5^6ZIez+s{SdWMC zVOhgU!|55=em8E5)>z>ck86TodH@YJm0fl;P%DdD>3DMsOg)_};uLmEYb4SmfeIwl z?x4c}-T?1;OyK>-UUeh0?j&H{>I$A*=!Hw=!WmnRo*&1XcWHg~4a|+fc!XXmT{I(V zOAwyoD=F-pbJ;#-T5HKFQ!F@s1@X{LSK^EkBE3LME8f6nhYLe7d^Au)EA?EO_=23E zGsE{JwW92`c=ahOdzmBD)vRh9WK*JE&O0?&(u&<}4QcAK$cR95+@pBgCrUX{V zm{%~6G3`}r87*{$62bQJ&GCnwx#rSQ_h1WBmpo#qj)7Hd>sbuu#4nw)?VOYkcFZcp zx+}!c1C*6JLtZf6JeeGljJJ}lL7kGd_A(UQywEi7Tv9Wf1RHb2To}BJqrf+){G2Jr zqL$lES|TSEV=Hah(rwuG+gRKg?=R)L=V*LIKI>KM?8Bko6Nj$6EBm&m@G0Q-7GLa< z-6MRlM~bIm>F@Wzo>g}zyA=a(b5!t6i=hKn5U{LPz$rYd=UxFXQ}J$DhLC0oqr*y` zJE!byK2X^NemOv9ZcPS;n60M<#^OR}u7uqC!p|b;C#cQrx_Xq^Y=hX;OAqYP-`#3R zyyo&$osPByez@6|9&AvpS*tASTYwAWY8qx;keCes34r+>a@rPp2&E6a8f+q9Nuu?;PW2W?!_UjgVb@&9NJEjk9@wMByNm(52Y|d#MWL0s+Zt=tB&lx4 z-YlXGoC4yZ$JC}c1Uap@1%O@M(7cGtZf&ezDA-8om2sz z>CMN8V3Dg_dSFjG(|6s@^e*4~`TW*H6F&+~?B5-?=L+ZvuGS;t-|1>S(muUV-;soW z;9xzg_)!7J;5gvDTN}PGYV;tj1cv|{Otb8&I_GLjGKMkm2^_aeHV{^Z^zrHtL0Q3^ zqOw<}G{CUhz;IcnBufl4&$ZZ06K6C2?tO;=_zqsRhO$xPrGxe8`C$&$AUUx}(=vuQ zVpepjXCDC5W6tg|jkuw{F~O*kst29mNzFGI(FP5&8sZ^@nQj{0nnfvuFmp=^{c(V=GPx|aeu z=iXxMCH2f3Dwd2LkYw#aYlSYDJkZi+?WZ)UmVgfdM$ek-7-8YbyJwBV=1A&UF^AAV z_O2bQr&H>u=#+YwX1^4tdPm)g!-$_*?(z)p8_x+N}P5zw23j zukyW?w)5D7)FWv#V2v_om}95qNs^^$Da>6#SMk4;7}r_qAkYAlb@sOaePQ3nHuJc7 zhH{jOY0S_Xajj!OQt>t5-O*$9u^3tE9e)mQ@xu3-j}Bi)G?PLl4fF!wVeg>ZTPP3) zR0XcdT1g?;m=SQaWukwpTO0r+WsFaOETjnFDtApZBXRW{KvY;awJgwrQdfz9w#K|Y z*}mGWB@`%valCb2`d{sw1+S$SWzQ`FzF^p0EgMc-nc@}C)2Yot10B2(yu(V#ybe$? zb`p^R&OaEDE2CwMs_GiMV6!nYf5zT5Do90VDmsR`bE0Uwq|j`|HLDINdS8}KI!##L ze-qYc`C$*Q{K&krzjzj(i=>A;XX}ykZ*|a?m$Au_`03#KcbD>uj@n~C9_p-}Z1jPd zWH72ZW|o*uBmry#b(dhXwJ=!XWQCaw|2Y8ES59jW*~Zeu3gQGJ<*HCZU~KDX4*0fw zfboJ|AVP{VB7)XoN=!UXKg#Werz0bgdADs%SY}rVVsc_Wp?z&Txi=j zY}JZ8xKg#&SYdhtmmB0)mA4@olG?S<3m8I@Xlq~vP=p}hI|1rL!`pg=()$Q3eOet% z+(8AT*2_5N-OpL|@cypk$w|7%-ZQDWr#R5 zus^CNb*T0SqT1i3d!Ax*Z*}74Bf$r`alcQUI?VSleH_w43ZlGQr<7$e}PKqZ(q z1VYDvMolHR&Scr)z$O5YsWkd=C6wJfnFrvO)&saqo-Q^bCINg302_xnyKL;7XJf@6 z04V$}+lrk$IN`|~2(+=+!-X^VuMy-&i$8SdRv?K1zUYQY*FI|k18@O7#pFQ(L0z)c zF>N*nmQ5_Knq0vFylJbTp4v%d^8hW~v(%kp0&xhdIXhssnxKcFg0ZG5DX0xF8|WhA zpFV6{x^v4p6W-7|wl^&OuGk%zDYP}rKaz@*r(4rBe-UsYb*>rY|OOu3c8{0g{kg)M&04kp?g}#et_1oPfV>n zjPnyP&hIipPx-ZHxp&)<^lx_XexK!ZWPbY2z8g8e=;S?CcJv0!ovnQE=VA;{&X|bCtTjf}m4_!_{oNwozSorO zf!%|k_UJx&Q=+{!j6@BDJhQa%Dr`W!Vkjkr#uB(d{NQuqO!=0OOJGl$JyRu}yL9x9 zb7noBiDO`KGSHn(y};)n*p(_r#%r=rLT@aEJmwz7NAtkAjT~l=8s{>WIRl-BkfGmf zbsHvAA&We%me`>y;PUNdM_JJYYQ{k31~CI+mmJpVN_)D}e(g&8Q(3x)i+=(x{$c{^ zxtn{d2e=$5KF|yNastYpVjEyUMOihq7|n=q4AgctFcJLW zoxNx=OvthfagSZYh`q8M5FpK1enV12x($O&f(Fo5_r=bd0tmGQl9*#{oNtRIa25_e zAfbNY5q>FD{b=&X)udFLF+v%i?a`S{2=MB$DZ39xOwaiRXxhMWXWkfsWKtH7QkdkM zS6`MarQ9aOgf|c(k37Lqq3u*bh;rC`ObMQPUwbe_UH1Zkk;`^HtDQ6AZ5#z}XXM3B zd9yQ?fi)(E4NI}?-53#`ca_En)YYOpD4~e56m|nsWx3@!Y-L*#8pOqInpPmY39bPg zXN1W8E|~Rp@|V@UgV%t$c-5wtp5fE*_JcIM{hbNFhoXK0iuz)X>bbOfmdkh?Y5yDC z#xLhu9l4)wx$jEWFS?J9MR@|%HXNujw+B+>ml#5sw?b-x;N}$Fh`hjk~x{+emM9$ z^-^Z}4`X{|_ToPDwb}K-O zfyr2#nCr;3N|J#UyvC0HW3I{4RYz+t^Tp9;n42kq8B6~b4bGNNz4(T_Bo(kihi>b_ z1H~}vFubnV@z4|#U4EfW*_Ht*SeB^ftpjsfOd`xVdWgg49<|)yM5xnqW%V+kdhp4a zuK42gW9NVD=A&1&moU_r#0hp@K(O+{{#o6!cGU=;<~e}!gBq4uwC63{K-ybed4(Qj*#?QO;;mL} ziXJU?Y@7h$#|U^1T5oFriT4C*-yk>0c@ksW`?$v+QLpm~k znk)4?IB;bBa98TF6u(Gi1;Y!P1hWH^?afmwGsh{ide+4B+r1eC6K1S=L1t`rAzD?M z-3qWWtrBpovvwjER0r93&pqxIysZ+9ZH+V)2L%>JPtFUsX*$~dRmw|R zw2~AUp<>&cTLt&DYsG}!kT zil=WCF9w5_?#kX&AkHl*sM?xQ*i0oAy>yYvIfowL4uw)SG+4%xvF2I~FxEJ-*4;X& zvehKHu=Vs>3u?nV1A7@K?DIWA$^eLy0s(t~@T`r3S#;oLE!^eIw{>jo;IUdCp>)mM z@-YqAjakd6<;UildjTJ1wE<==MMVtTMG`HiubrV@Rb!oL(GAr)1lU zA-{NlmjZ?Zc*_xEex9L&Y0$<+Dr`8KyCRW!F~JnmXSOHgaCG!Vgi+9)^lQ7rS>tIQW=^-;gKz!c3C~IjxTuh037QD z4B;~MH6FWvO%UTw*g`WehyuI~bZ@MfR+|`8X=CUPu=c?9G6j5KwX_s_tgV7=wlc4Y z*kU@3oGi);DYIt}vtMy=U`cFx)7u1hi=>y}j~3dn02ZoXblK~r@3fq==MDbT2Fn&@ zn2g<3@S6aYaEk$>=N7faw$m($H!(Jbfks19mDTiMBtiak>=veGZs!7`=R>kBJSS+! z@A}rXa@ZpV$)zt5PvY7%J4OZ8c-`OjS^m?*89zE_?BATi=X&VjPE|S5{SA)QKb03c za(;?)wf+b%9C<(7!FsI519DTh2hX6U8K@1D(xQ+fCR`=1jbCf10OY!LxPuqrZILCR zdemC73Z6jxUKQ*&mDx0~K#-*1;8dfh>dbqSqWBAc)-|(_$rg$1jsbqvF3LddW3L{< zk=I}s%59drPXORBG0+7FF0CseItDWOZg^eqX-~)S!IBCnPJ}8K0K8*}B^3~1&#mHt zyN2C%w4C!yxl2p~Y%PH-W0e4J%|3Iba7F<6zI3$ab1proW34)7u|rwV<1`1%U3990 zF|`TN@pDtEB%h=9f^!Lbv**YfQo9-WS1bvvIoiZfu$RS00+UwEHo1eK11HxZvb07s zhCFY@gPVb0Pbi~bI$Os%8z0ZPwR>PuaaJ21P+?s$Nm!|};Fl*zYlpO~Y0Tycb{eC# zp3+zv7#Tx{tM5_fmYz%Ge%(a_zTXp*!`H1O_O@&##(ZmHgwp`W#aa-H!F*izuD#2- zFG@ol8vVg&^w&hoQ!(zXHH%LlwqJ9<{xf~)NbqMIurDPL9Z9~mI`P@V*U`RX%F3F0 z%PD|)0-9Ff8OsyMlkXJ){_s@+bTA~mlJzyFZvmzi%{}DWbQQd8Dd0&+z`YGrW(=aE znWO*?S1aHpL$d7BVr!Cw#gibZd=c%t;?do81!5>EfI$FvZUA*}jXt0`OcdY9x4^#; z0qOH7T2^kJw6zU5&}LHbN1%tI<_3WYhzf9M$)OG`441CL61BC=2BELP#K(kp%pJ$h zv-z$gg-bVVI`;o=H`+9HOba!E-xm)+ewD3eeY0JSGdI~~2KKK3NAqC;Br@-Au|<>F znEZ%A4Qco*Vh}(ruGSJ=^nFCUa4EO&oMm>+ZdKVoAo*Z-tdZr?5nIn0^cGrJcM56Z z`(p#YvlCJ1rJEHDwU>td!}NzGVYfDJ9mfKw9*Y#`zBlF-idbG{S!#Gnx7zlAV9Lg> z#{U>#onv%kt>R20YNJX}+FI<}UHWxj+Gn|951afvY_k99R6dtT4|mJzk?(JD%!(aJ zKi@U`Qm)UD__Lg|XGK4zba3#z4O0NoC3gisUQHMQ3Cf#8Un4lvra*<7cJSI6@t~SQ z&%kU|fa7chwjTvRv+6^DxqYfpR9R=06YBG--C>p3O(ck73VD ziCiA>@*wWuM|cEgzh+!`^x6)=WYN@ON&#ztjYA^jF@V(}JZ4Ga4O6tzqhF`B2zHjr z28IF?=+$Ool5}t|uL_*yTA4Fj@To=z@w#--+Bu&dmLI7D@<|}QhVLpqzeI+*$}pz~ ze#h978`eR|o@yxt%)6%zEo#2y!{V`$i*N8T9ARMXt!cs@2TkuCBn&GDi)ar_6J-iL+d^y1H*@$J6Tszt|OSK6(?U?ITxjrj^tyFhD`>bvea`}VBZ!?QmR z&;BO$^W3<-)pMJU?0&h&?6*l&M~Xk=!TnJh(~;&|y|`yT-{q`*kGRHCz}Jr1Z>4B3 z+>ECchLd4z(M4j#gl3$zjFfZDwXTU%ixuEnW#iHcoZNE*_I0Tc!kiA-MIDPx6?RB$ zh7y3BK%mCH!RbA+x?Fg2<>>D|A6*Wpnl0q+nmf2f$$jMBU`sG@0kCBLrOBGxq_Ki< z(b8vFWA_r9_5i#qp<4vbP_KCTTs|t@ej_#6v$^Ds!C*QYz;@DOuaMo)7E057>CM%1 z9=yh*>lipjyS71L*e{wPxK978RDmkHZ;#Ah-`G!>@+#Vjuqsm+eb0e?xTTGj8jJQo zYuJa=02_mDHg{(6Tk({mbq$lnr8C<`XG>rwlaAy|k8VF_(p!0CN->YYNEvYTFq*d^ zJ4IMOpQQ-4*XlVrL|KOs-Lvd;F=)>nHkW8$3JfinCU!V>+mzKZb3Q^?3ckQDv)IA4 zHb@;?G0w6<4)cadP>-^&`^o;c1lvPDKM(!v-yPZKD(c~`UOO`WZSLOuJ$yOReu~TY zM;S*)>d$if9y{_d8ZB#BX*fp%Bkba~XpOaU@wg`Vr3bKQQ`u!l10%Dzm2N(_z_i-Q zx>jMgv_>MU5~x5z?G6?VybjEt2ip*~F2Ij@d%>&M>I!;Y=<`eE!u4B@o*zfIcWHg~ z9fD&p4v0S?O9R2umLNRES5nwH=dyjwwAPYUrdV+N3gV$tu*4Z9U_20!R=ffH&liSb z_-LSpR_eJl@dY_SXNK=dYDKHYdg=bH=e&9_Esv$8vRh9WK*JF5ZSQ$3?CYti6jn&0 zbDr9o_&Lj)QvxewhUS`Ob_dp4Mhjh`MD~;^x?;r6TyyDQC+}S$sXSs}E1OcWt!FWq z6Tfr;?{j88%?<2rg6!aNe96)fF^cA{UuqevgSA&_1LV9`U%t5}CYH&X*x|#OB(b`& zcv+YUYa_Z&WfTvzw6uZZPs%Va{CZ&QuoJc*v$~Q;2sUhWec@*j ztQCxCc3nNnY_`FN>ZQN;=QM=sk^TulS8CM0G9 zkOIhmhn%(n+J@2xUJViwuq4vrErRV@!Db`^+JdNvra0AG91TA&tm9g9A(0J5?)rO= z7Vi>E>>i-^LKTHp=5A}ORg}T41j0p0%%B8>ew4wbVZD{Y(#GlXIJ?!!mvCID5 z*?caSp5WL$GX9;8-6QSO!}eXu`UmdZvz{Ln6%A?xy1cdF3!?(hNh`r2zy>2NyQ9U_=62v=10IF+^)vI8-OeAsp)%skg(6I7hi_`CNV22elf z*c!?Po0sm~qvwaYbA#l>x>d_G?}b^>g`a(}amk$BV;XToePe=%CE)X*6ZES2CXw0+ zPw2}%HxThWwF~>9=AOZx!wyv|mJs`;P7mPTn^or>><5^dhKN*0ybwF43W8>AIH!L+9RN>?QTgi>*|49FSz~L2HFBnBmaUW;v`hsg{5b z0Z`AH>lk6-$!wPzhs}}HvtkaRB~0;jxIG9OnrFwC*s{Lehu(AH>yA9 z+0`Szhj@3zjwDZe+`j?OU1uG>%F|og&SMWUmZZ(v$OUU{j-8e#NtULiFn0yZ#s5-b z@M)=os00Mq*ztDgF%&NCvu%@Ea*fu8 zp*n=rZ?59)g>QKaH3=>jhB(}*RHcmR!6snU3L~;2kfD;KO>;?UxW^jQE`h|r3aYV3 z!X70{X1|5$qwra1d0^@?G!SsR*ehgn_Sz`Qyw4gsyCdQPT!fa5L|P~D=K2kKZ-*aS z+CxT1CH7=q+#vqqR{_(kek>!B2K~u7njFcf)O3Ej! z;9A}H0D!mq;M{O7wcAKV)S0u5<(NI=85q9i0ahftb-`at5)YaVX_72345T>NhaJWn zP@jSep#BcIsNDAQZ21v^{GYA@2D>|JMs8nKe^&KRi4#b^v!&jq9Qam@3Q!=44O_qX zb1f$BS|2^1yO8GjzskkwSy7n5zBDexT1!%v?N+I(k5qAEd9~8QEGraG+p_#R*&7k@ z(vJ^U6dmD8(&V*0a53Ui3t1+bpED0!pTm|DWYD*!-X6+RV&$al{5HPo+8?iixoX zihmznr!PUHDDa6qie9QN{jt`NJ#s4Z#NUzJGr1zfCH@+`{_BsC8zY79m2n?hIj%iD zl<~@Z7ta$SA&Y>ORvveVVAgHQC;w=aqdF?usu|5eWmk-RVrqjd@Im0**?INWOTD=+tDCuVV`jGKx%{KgIng- zs0YipTnUseY$J)l%wy_G>{4AQRP8$ zGZ3Wj>+lLWa%7W^!nhIa$xiav@z%w97xtgDithsch&&YR0VtCEz8oWwOi(DK+(8bLMZ=4{r9vN#{Cz3r^vabBtT#zE>x{kLEX4K_WjV!t+3XRr0M{%VOe+?@hS zHB_U={~-6SYb3bS7rjd2)AG#>hCeZ0V5`(X4|m2R$4b9lASlqcx<7X}pImzR9iIMn zbjeKmtaS8JIQ1!d;>b)d7d(X~T`|_$VF!5o9ztt5SdzU0m?uD7M2OVxy+rYt59;JD zNxjsS$xw_mRm9e-C#D=DR>M1>o&Yr$!HSw_rdF#^&c=C~qW_%BFqz})POKrFzy9$; zq;yOUfLJ7@1a(;0PIY}*Pm5*-Xs(RvMf{cfi3|_YCk&{)G{bU27OHaQu#XnfNY+Co z+3Di%Z1s}UW+8;a-NO1y{wuc465Sw^_|#%7UFq0esbQZZ0Pn=e-R{8T#71Q8|LeG} z&^i(Sb6jH|i;w6E$=z|W-|z$BNX_;UjjMgXHreB6ykp6=-6mILlCh`_7H>b@NW3+Q zCiFbj1p0AbARETT1DD_@u2 zTAj=$uC1(&8VN}rild#D2|u~wdgkUl7ZNYR6pRciXmK)QN6<-V;QLJ509$}02GRHl zsc4;xL$TS2&vrJZoD_Hnxo8iKL>D8=SQ`ty_AM!3x~B(0>x%6AG1}N(0`RAW%Ov|FxRsbZ(0ij5UHc*aMnMpAvyKq7$?W*xXuxIa(5R z?)2glSXbHm77;$w977di?IZiR{CRaE<67!ToOL#l)QnkO^mOYaQUf}{yYxa=pDL}I zHMrFT7nOG1c~c7+SzLRIr9A?U9AXuRWSM+AN8O0Ql*^;&FwE(L-0)AKAs03T!KTmn z4t;?v?mP*c=Y~OX_Mp>d_UyxzS5X)t?6aMClAP1NnYXwz{4q3eH6V;4Zj9orTNHnr zK(N->>vOWP2UxSq+XjxqE~+vYs=NIOg4&D3J&(#znncV!^Zmnfm${r9>nF;5bwBCx z5DD?`AZZT?@j_hVJK!8EV9h)k6$g5A!h&+I`!upX!rfHnWaTOvIH})@cYE`nL7uZ9 zp&cGgMzO1yHR0nop5gv&VoY;+J+7Qb3u1GXf_ki`i3Io#P07of{jGs~$c(`fHEIk= z0vV~}IASMUyTQ#2EAzgH4*((L|2#J)?0=ps(EK0Ib$2wxo*AHu5@D3=N;)(e)je_9d46M4m#$gn|1vx z5m+1zscN-U3UGXSoH6i;^GhIZHrxL2719;k@m;B~zHFL#Ri?X!jZOJl<=&4Q^R-;! zt*vIcHf+FJ&jZ{28{6Ph?a}1l^5YjR&|sUDZj)>+1_a?aebw;A&|#fsAae3 z=$B~6L+~$4r#}F(pY(fO0@u^J(}bjpGg>izcL2jByTtmXFX~QT%l1Ar7uf!xxgLlA zf6ZO}bWwad@L(t< zB>iJRtNOun=;b0sTY5=Pk#((_{GgDX3aD8E0)Ng}$^i+L`zw^hhFhu#L@$RLXilOe zw0hkbKNJGh^h@ps&E9K>q*jsie(b@i0xyE-4)aE$_k-En%;fd}?$p?@odD8L=lXLOOD=Ex5p{8xrMS*oCzj6AIclvv4uJy8 z*QEt|Vnor9Wb_|x<}upZS*ANTr{5{5SqBT-EAsrq?@)*&pE&c<$vWxEKJ?M1gZ_Uw zw|e!4)l2Y$bA>%2Foe=)7@mjZ$Cp6V)zjWXDrL3x5 ziA!_MW%T@M4csdpq;7&=<$WGY?IVJ!e4S~^ntZ&W>??`WIZ?s?WHS!sNwD@nRGx`R zCeB|hcO_`UE|6Z!?;FQb+msblJCG#NQmBXu_uo#}X}~U77$kb(LPjnB`6Om~$vBLb zABHneMXJZ`{7LXr9swJLnsK+t_Fi31v8|o`Pdy}(W-lOeY$unV^9Yl04Vc`wc41>* zxHg_#Gd39L3CG%E;Gnn+8v?=Cc_iWUKjmp`3bG0p9n$_+pddn~&a1r86>*+)8(ppw z5g4fX_R5=a^L@?Nmi6Gjk?wk6i6t4*Tg>P^li-oeO%-q6q+vI@g5|HN%CeShXa;5u zd$_bF5h$HU!^FtI8XI3Tng2Ap|5}XQqb%DQGpmEsS;x)7V8N^4AovdbWd${0VFey$ zCY6qdHCVIH5`-xO{odyEJXqLq+&-bA2DsHmnyt5rIK<>5=T-Il#B7cs8w9hX+6Vyq zK*O#9;q2+)F3s%;dHE3)z)sY-8Iok$gy@(oEH8Sac9=o{4*1NAxVG&@Z@zW+BB#R# z#eLG&6;%O6GKDjRDpNKn#M*j;TE{zdmpvolAJADyL9>swfV&LOmc@b**lUj8#i;)S zUG@*q4S{}&^rDh~H`Q-Y7);XD!1tFCTP(LTZ*zN{aK(R((S)OLv>rf9KEiC;$e|3b z_9yZ6DNEC4@@4H8Qu19w95THd+tl2QR`A0smU4bPL!sm&xh>w9vMUM_Sb@*Qa@Psv)};j&Hf z3VQpodw!a~j{bD)yJdv3eFlP1bTOytc^IAHzt{&YvJOnH67^^mxXa(hLrB)2pA4)# zpZ;3qK(7jO`m%qNzP4Vv*J?l$4%E3-&R;p+MpTw-KH?}PSe^Xt!XCqENxc$Z>Kag<~m+U(G?89@RG zXQr{%a}8Zbld1?D<-?!IfAMh=DhzqrWC=pU z)$3Ul@kJRyDAHHh{C1i-IhA<{$^6~Rc;(rfi8_Vni^`p(b{0Ie78<%v zKV(#Pgys{V7!ex7{acwg%$O$V)`x* zuW*@X6y7Duz{V-xLs7|k40%MrOb^}#%stZwf}vh<+M(A2jwg>=Cban8&^<(7UD_aA zZ~xdpr@WB1;#WzwjP;6=_Tu+Kw#@VE9qYH2T#Xf=sA4@DxN1*mSR!T!ZGin#?`ie7 zF7IlmU7NeU=z-rqi~F;Rj7B1|2WA?JRD$SE&|234PfqxD_W4tscn&SzJe^P3IveTy z5H7inRy&85+`Ro#Uy^GDWkwFr@Dz%<&Spj`6{caY7EN0QZ+z2kc44V~72^eSWW+)O z>v<*8c2K0;5XpwXV6Vys-^o`rvW)rg!JzE?hN$zh7)>uJLqmc46$jC!yh(eRYfd;A zpg8@5M{N!B-7VY9#{OKd8^FePd!Ht@6jq6AjCs!Hl1Z+ z-+JGOBD>vL7?|V5`3?y~UtajREo%!0vOL=xVq(X?X~Oip zR0BbPR+S}Wc!INM$L>?Kz+{BC#Ev~ZkI7cs?qV-~)VFlszJ18} zxhB2Yh8a5`&%iZPEpzhw#E%P;KDoscV8e{5=D%V$TVAzv%N0eIl(`WkWicofl&?i7 zl8r(ZU`ga%izd3P>kTWSGdBG)(a{VYeo8#jvH!bZiJkH> zs0ph&2icu^g$UW1-M;;PwwJFy^SHq0SSGnbdkU+Zf8UCIjUD+|3yoDuFQi%>&=6e~ z1kpdfg`BGVN1`T0IpC42MsIisL^G4f=cGSN%}5?Z4W#9~%n&rK+v3gh_;}S8oHu@3 z`j_g!$H%9g71pk`8UC82Kr8sOi#d!|xo(RWD?{4#nQmXK_bQ9G9F!ej199dc5;43N zJ9Zc&ZBgl&X*CHTOhl6pyTv(o9C3Kv1rp&#VSoph3`LC+5gV6Clm23bW(2`7Iyvu7 zvZCv9^P~y4p0@3ar;;+t8T3nQ12Rdmp&{kEPrx#qiyBUnPmb;whUGvJ6pHCx(|rsJ zv+!&SpNIe>?FKcNon-R{tbY;eO>GAbX)!3Nuc=ZDS;-+SH5$S;U0)$XQtH^&K5?$x z(n^yfZf3{n>RO*a%2w z5hncu`GtaShU)ARHd3OCEe31c)p6T2)0^zCJ5q5*OIvA-ZjD&t<;m17jMsDa{iRy( zT@!MDTDy+^Y)dF`#V*L;d2;9KIkKC!u6~x>1WD>#A$<=c-EplM!dPQ%*=+Wko=fC9 z(w?uK2l(xT{{FtCfi1tWf#;27l52My%>ke5TDy+2N_%HOwlcrHHwsAPh|L+Kj6+A2 zfr^c+Sr`+YHz{#Yc<~(=Ch#2fIKD88tHS+l4$gtfHctK?-)qQ1R37Xo?@$F>*>O#1 zPv{@LYygw+6?K~#OuT%PvQa(KG^2_x?-YY=OOKKLu^D%Cls}*A=Gb}gjFp!m*h*tP z{eJYe8J)siH_K70Dx^}Lv$F5)X#T*S+I8*OeJM4RXlY5DWWDSNxms5~b2R+APXAY(y^x<|-Ixv@!=c7L zv#J~!EUFS9?;f8>NpWT7SoUxnZ03Y2;aH}nWhJtfV8q#z!NAbh95%IyY zEABJAnU%f%oKEPaFn!iT{z7(PwgzR*K?gFP@jjSGQ{ z*DqQEv3MA&7DMOCk;L0{%=(35%Ir!4EPy4y+$|KKy$FGVHN+=E+m>0BC=6LW4L(;z z>#Sb&FzcpUbL?ytfq996wwE0Xb7YIAz2dP^viEHr;BCY(;h2&B!_W%z<%JI}@<@af z%i?+wa{fJVavv?)wnK5KJx4&tZ>2qqVR-m=04-WsKv?0H`u!-F9?pR9jj*D6^!Ug_ z@2B`wyEi(E{{xpHr}_`uIk^JMG93FbYI_X0=f$Hi-Tp6;C9zf@eF zZ)|p#A9R(y2h85yw$i@R8yWXh%XU}<-21&u5#kp?RA}1@)7(61NsOf?8EN{; z26gUq_I-6zW!6A%PMxi~Zolf(%E+AlqXMqFIPb5d=T;~(XTBho6Kwv1&HbGla%NTW z&6J<@x2Uw8l;vMim`{vN<2FSQu~;;)vQm{SanTR499no{mZb%A);j5A$3r&?cJ}%O z`+?l^Po~D+4NgGCvn^c2JDL4q!Zdl-@z3RFP5w>VpRljhSWYwKA*J;b_-DQ)=b%cD z8jwN+i`@d`Dzq9nE1GE~Dv0~h05|uaav$0pt{VJ0ubx^zMSd+~I$pVdN2zM)2|0ha zgt{ctdMV^zJx$xfaco;>Yw6haZb^AVd05_u90!8q9cG|HLhW0jzTUbK2`&i1UvTOl za&J6t7;!G45ch|&tjt7;$m@E0G!NN04JwH&Ls)X$=SI%TkQ`iKJ4&{$bq%OK7IXD) zk*U#?UBGmK|@+Xg;wW&G?6S&aOzwn-yeC&R=Mve^sEnCA*hsx2culDc&FN4fY#V@|JqOnXaCHPDH)>OtG#Cjfmg>Br>9Al#cqSGo~f%B;nqKn z^MvbAEfnsw-4538DAfb&)iE8r0iG3aS@Q4W$CuABk5JYAVL#_`{LA~*6LQOIpR~pX zgOl?yomjk_&@2fZ)?mN$D~w)zShDCZ7lLs~8)ZyO!y$#0}eT< zxF%Wj-0RrzRpuz$w}QQ$i>G~Xv|glfoiVJ6j5&jEaoycgT1lMRQo7K}F7IPo)iTBr zPw`?8ZS5~D3(q4mcfFOh<6iVr`|Z&oDk1i!YS0p_q1c~gj0vbJCx)&Za=87kKM5E6 zr@h@`y3+LECD^-N$_#BS%j9fMry(^2Pc`MoSLH8f7O(&A>jPelx)B*w7~UWA-uDBa zmEmFD*xwFz30~#|--Fh>SQuQE(e~U9bxSRBwDHoM7p)CYzjO--iO< z;~xY6@xM+6iaiE;|G|~YJbtiFPz4v9E(I%I=7$}SbrhlrGb@I#?}4v|Z9fapct#w& zV~KishP!B_BiNS*^JYawtlAgAlJmETP+hCnlt*78v0Bo-Yd zx~!t+%;T#+JH2R(6f){8i<<7+hY#N!S>aA_6jXI*h&NX6soXPqrVnAz$w5T!LDPeF z(qP!hq;H#WmBeavV;FAR=%O#!yB38{H=k~$G9l}i*~yj)69;r{Fc^(RLIJwc z6!X&{Vzw9D)?KS|tkLbaDb|Xn?OI^Ssje5Ic~DBZS;>>Jj9DE=MuR-GAJdjg=68Gw z=!}0$<*T;{5L_U^#%{(|XW0mNQwiVV7_=0E(t*dI1I4C3XD3Hp%vp2bafLv+K=0`6 zP;|#l*>oK(`Us=6L|YJ2^YC-upMl~ukNzKp@7<(dKv!}qU!dr*V@3d(>~iV6*oqZ{ zC86*>H5cJjRoQ@L65fdyboq&4C@Zw&q>gKqNx#m|EmI&4S!6?#8ol2w%uj0zl!$Tx z62kJ^e-*VAMfNhryGxav=iTQ{FD75h>bv6w#>KfS2+Z3#B9U>|0GZsC6a%8X#7hh$ z_=-_!ZW1ekl1rQ>RMP4*4umjtb|_q&>=9p{ti>t-90>N-dBU1S^-Q;N$|U7tRn{v@)z`2flPpZ*u+FG#IeK`ByU!2+0EWL{Pglv&f_;o- zlFb%?HIB+XmeRYM^z29QVH-*eg#th34qK^uRONCdlEu2e& z#y$(K%EH(A41<7S4U zKeNN*8w|r>XXZQ3O=QRezw+4k3dj)OIY3#`dvCP z4ReG9waI|oAWG9V1w=X0NQ!#FKdSQ=H-SJ9QDC@PguTYvg_(rT@837pFxZ54Oc0p} zDl}u_;GmD67SP|3=p{7;v-n?G|H-c?5@wQ`;IJdGgt!1d7V2#D{*%e|EOOov+iW;J zrZX02BKDT-$irUFaf})N_a)_W$tr+B;W5kX*h3-@w|upS7rsS553~B^MvU?+9IDv> z)_pAu6~L7|ja-m!DgCflQZ1d6QZ?qUg(b!v0xdgEz!HEk`p+UlUv8f+qxH0q{4yyf zl)9W6z8-#^cP$@ZBUoB?=Lj=>^iAw*)nNm-Z&3X;ZnjnFcO-zeuHyXKp8RZo5DX0T*1-DgoB}n|%`NN7Nqkobn9K1F1`z z52};oW6u93Gq~vAX9$-dK;DQ?`>VHkmnKq*Sx`Xr}HzhIl|D5(jfxa&=q?9Luz z4$I!Iq<;g9LH2ju4IfKU>y$VWNAvgEJ+Ev@6X;*iIuB>5 z+mw1$>J>7CmX~Rz#JMhD!hiE~ga~qUr&PDsy^$Z*3fVpcX%%W0HN%bmp6^5(9$l-i zobZUcl@OnIdXe0S8L4WQy1!eIxT&b!>sC(YZ`$+Eo<%1~z(1`69f~mNv)X0P0LtZA zks=kEZbfIp3Fq7O!>istBZ z75+|v(u2k^@>}*>qFO(%PXeAM9AhRMg0pkQ-e)nw1n(UcCr``87^l1g9LXI<0?1P4 z*=17jK9`J6ZZJ?}=>U{7;vz%x;ng#MC`1#Z+~RUFD}_b#7BPH5)1-Wg2pr)afF41j zuwjewal``Ln6g2lf`qd&MWGEl%igoZ=F07&pBZeyIgi(_&$RM5u1B>w2;e>ET$5ER zfHwDnnylcUuY}sw4%acrf-xfz4fA8XOXyw>Prxs2egSt38*WKCv6>J;E-zFryM`q$ttqMqB3l|dh1|;`|gy~-!(g{pZ zMpS#(eTJA2{W|6KN=E5hhUFTO!w53P6>VrDBM;{vzRT5?JALJQ`sRXd-pjTDj zV~{A8f-oRaI(WPq-RW;y$%M=nk*&fs4yw-PCGr&9=gsd3_@l9Pi~}%9li2fav~<3I zzv=Tp$nV)tJ)u1RWkPp)vYd_s<;9}?6T0fcCMmzgVi=~w{4ig{an@WJnno3#{N57_57rT%EScOS;#J~ zV{y;x6m8w2&X~xGU4x4|Z9a&{LxzXpCOg}+4?2Xqzoc@2U4I`$vT{)?h%BO zOb;BamIxlKzgyy>C}-K|E%gLY84gOniWzhx+)p@I%#E|a%W?N-EmxT)n{KD1()Yel zr{h=xo$>2^pkFX-ESvg64Y(+M;H8H6zwjqhZA>VMAnMi3kkidsC+q-m0GNV2qJ6tZ z7Zl69zb^99Uc3wcabQaudqH z;WMBlOmTU1;EkB~PebkKsXKc#C+rrrL|Eu%5P`PLzyf5HhT)VrhTg`lQv5M+h+pA6 ztW(=N;y6pO+Oq2kvwujM#b{uY3`Mi!*JVdbln2-cu=jqK*8zb5Dg$FMo{OsS_?#^| z!Vx*AsZy;xRZTl_w?gzf1$UNbUv0tg@~y_rvhgg^za2b^H9!j1=#O6v2?b9uOP zXAu;}4;O@ZTI*U~c@$^VhS9>PI?IP&^79ks=L#xpe$K|{T-zHp4?lc?)-gnJPZ`=& zhHz{zS7cuHA%Wty8!Q|@$Rdb4>zXgPql^t*?e;Ks5)E%>Td}StfeH6VJ@y*eVwlqY z*CZ5ih24**d5=78NJ4qIqW-QHoIcCW*&bUnVt0cnc*2LcwEyTNQr$;bx_mrkAVkz%6dc@Pk{p&0WM$;;&@3{G6M$T^?!a9xr72$DmbB#bUjaON#=l2(; z%ez*if>P=c?z;~53c@^s#V1w%JAUxj4Mc78>o_x-Au8X$jnl?%#>_`b=*<5bek;6Fh(VJRAq}wmWbjnt&S|7fib|b*2!oUIi~^; zPhFz*+Rg!3F#w7Nwv_ij&o|*|&+h0wu{ZNuK*)clMJ#U*nQ_k-BAMLRJ}lbEwS`poU3aLgW2q<{wR(mfPWe zSX8l$9MeU@SxM)}%5U&usl0%2Ua3m7Q8*l{lSg4K5yaU=p$D#y$3AueA>XRO1!hCN zi=H_7Ifr7TIK4Z|h`_m76dehj{9i%JTyMOqu%*n z_?u!bH^o)#A*fxf1`aA7{n&o|0zP^CMkWdRvbDpFLZoHA3G}rNL0h%dFuCcb%Tr$C z?a!n%XT<+#fEk+366+(?C>NTj4jE7pkD1XhFd#O@T61F>X=@sl-w0<4=2;4Qgxq{- zSn%H5A#X8b`RBn0EnJ8WUM~&(+y0OP^?Qfxo1*i;W68Q1qqdl{hrf!+zppuIdF3+r(BCKx zviQpInmZeu+IdS%X@K=RVQchMP?Taa$%;qp^-8RPfhX*qC)4;B^$~}}!00N85z_vW zphG)dq?jpB6dA?U5shw-gfC5(UuwAF_f_QAOo8Jt3}LaC)clm_EkDnhz+sZswJhfB zo|NC=V97yWgCJ~XrOxN)C|6$VeDt+<&@nY$i+1d+O?&nA6f~w$lOBKJyAu?Q@bX5b zb$k&#;VZanVg=nuFQKU<=M;SQ{(u%}+ySl5e8P^hwqzh4gF$7-ndu&? z!-M#!Uy$FIQn58v6+PB@x%k@t|2#y*TjjK#j~$;fln1lwZj>?V#Y_gUUx{&=&=bx< zLzI-*uFJqzA_eC4QnX>Do-q)MuV_Uxa;Pj5!wasBY%`Qgi$xS99(5aTTg-}!GD9Ir z^2r=i*G$kcq>O3U`%Z&CX8l|KT({T|L5ejZY9SK6h%j_+5HF;b}gp!7qaH*rH9`&J25>{86t<*rt~Gw zz|O%E1|}V5TY~&K%PP4~A#cA(th~_&Hqki0xY)Xzd`BA+`DubZ!c25}qH|0x+tr7^ zc;btqa@yF6_~%WmbQ295NEC#{mlK0>C}P3JALQk~kKcvqO9MPjny>7{VYxlo?uEn| z;`9m>iOG0LAn{}~CJF(qN2}bzlAhrYF0i1oIiP)%Y^!7{J|Er*ANFj;$=!?fAP;J? z&7@fVP(Yvp_o&$(Aye3!>&#tdH3%#HmAATo0@EFM%>>@5bC;RhtuxEl$d00 z^uSf9`Pa8ClvkXROT-&QOwDn$(r~2;?3Bp8-WSTf1~FFg=XPH1+`}}i*J&xEj4yNN zzW>@dIaX-wNV(qAd6k#F8wZ@Kdmu_SLNHEnSg?$v=GKfI+dmNwz8P$q!#!-I}eQZ9FKjdbb4Nw75q z;UNp){#jMdd@KrF&_5!CClsQW@Ld0!>r$0Ps0KrPanB;5d3Aq^8*?Q$Q^z^-r{&d# zDUy!-o{LQL4l>ynGh+JdZV6LYGMMR~B7GgbNml_IwWo;D1I6pw_nv!$)Vb8SRt|kv z(sn@2`UIlFc!UJAuI2H*r|bIK04Cu(sb&6|w*Z4By~8kySjds@`l|};{V7d{u#%H{ z>l;YstfM0BH?IOKe;8DmLJ9{MVMLS!B%D@#- z7o3F0C~zCV;k?+^b>*m&2CZ1m`-!g>nITgqRk9M=JAy{dDE3z|R)JmqqM9Vy@{mZ; zEjCVq8%O(&^d}F!6T+JGktXRg|96L`iBSJUmxt)%$ZB?% zFtj2WzBj|x1X>oHqDeRco?cbX!?3(`TU$hr$taK?yK^u+g?IRcPmGk>9m50in)S%P zBl<}R{=!+rIVdE9F&C@TI@i^NGNsZ9-V>}(;!cJ$2BwL*$O>r6;5t>>bIqsM-`wb@ zS&L0)Zc!}_nbyt%0)Z1`KO*7iNyLY}u{w-G1D_i#pP*Z#^Q8G}e^1enFxq)LNxBQ* zg0;bG5pD(wb+=t4(ODY-FaTULO)kN*%6e~Yo9fsbarpfESASaj^yTbXu z-lv)nB&5p}xMmp!QMSeRc# z-Lc*+!0tw~Lk5UB2W`mS+iVq@>7>DeCCyXPO8&a<{R)sw@ZFV}Pcna$R>G*aT5IV; za0gW5@LL&XJ_Hx6V7ocRy#`U3kl1uh#5h7m2OZr~s((H=0NsyI#se;EhnU=}kr`9uWyNnC<(Wxu$8 zq6A;hidH}oP?$5mLM9_Q=^ZL=FLFe0fXYw=^SfD-$+wY0M#1(nxqK^SF@__@FieB8 znJOsNsv(VOr?&qx0;~9M`!LzX(6msYt!*YHc{$7YDRxx^MF4UGdo= z_kTHu-BXB_zP}C!gnB0&@JZ0e{>!!(w;m%mPly(f{grec7AI4mAjgnT z=39hGL~!W0#DvxZ{l`F@BdZLlQ&e*{lTuN#f+?p0S2vr6D8-|pFS>Bc;j=Q`5irH( zC;t*R=r$QGJeM#Pdv)N9d_VWzW(H99U?dpP;;l~Ihj+7cj=uTE^+Z4HJ-u3q<8Is4 zc*6$n!R+P;?6-6+pKA|Do8{DK?#Uw`ok>J4LQ5jBqmg(kV<;Vtbe}h+J3r|{aUk~M zL4uV*b4M$kanhd?H39X=k9`|`8XLUD?D>iyD+6KE$3NaVlRr=jYllv+Gd}l0pH>+C z5x!@37#~9O;?8{jLetJ!K!cKuqYPIeVF6Vr$~JL9z;_x%J?VUG7op2PMQN5xSHZy` zggq->%hLILM?6EIFjwimvG_l}H6Gm)B_=x9KlE7QcAxZR@7baYhFcixp^4*s%yvCA zR0r%*+?a01pwA+pU_81%a1oNJJezA;TNZ2$7I|j&x1?!iVMLbs=sjfE(?MHR4)9VY z$Y|GfLJbLN&{6iMUot;<&iLo*2j7!L=#tdwGA^p#Ur!<%$jwD7Cc(6Bd|Ha z`guSBLqsYSDys9Q@inr17Ivb;2jGGqX~6pb1zb%QK82_xQ@xRJ+F0dsD5LFuJjANA z){^O~=gLR7cUAVv-X&C5sOM_rUWC0Rk}0P#Z3CzTddGK^8;o;06N3?s477g8n0Xqd z0CSs(Xv>!Tze;=*HZ7Ybr_aLy<~Tb*XpWeEWOhc^BgO^6yj`*L+!;KthIgpkf3V<; zQw{BpZFlKJx42$3IGLk-oRdH8y?{M>5t6yK5!*Qw29_|Ob_#)MUnUg=_JOweGVI^K z;}uP7%51-@$?oJ_sEc5&EU*dF6d4Jb`zKZ0!jJIFyz$Llhq%A__PpIhd?|gG;p||R z6vr3wXC66DTYKL8$3MSc$cul%5bqR;Hq(3Dj_z1hzcVEr7N&>?!WvwFC#Y!p`Ku{O zO}?t5d)BC*+72-#s0y8V{P-ZHE@=4*wUNH`j24h7nvN!{n53CKrKm| zZO;iUbmt4n@py6$*AjOsRs6j_-}{ zrRKSB`8F>W1%z+q$UUK*$6e9W={A(8`_e8j-?4z@J=_ z04bsHeefwN5nj}hYLqtERr{gcyaqbLy<@ptW0Sv8Aq4W&eiW4{4tUC)?DsJnAYl&3 zLVG$%dbxQl4Pf})9%x(YK>r|XGS_ld=RhQ0^YDi99Q;kK1SLGO(9h0Ro5`%4HZGLd zZWv8qWWyvE7-37q4J?AwHn)npaSF3-w)&u3O0y)+Ag>go%mwiatw|)w7($6nKl9KTR#ySZX#c}s zSU3aqWfHr@NVx=+##y>cw2b33Zt_I)gYM+zYx@vaHT+hR&FwfPG3FXRk{S;ozmp{? zLuiUF?&(>ATsU?sDKH8|(Irk)AgUl&Ha%b7u>9s9bdey@3jUKw5K?NRaGVIOs8ow) zv_%Y}8pPf()wcLWZ2s*Nt`>h(x9ZJ#va&d_`)y0l<*(u6mY)tSrSEle<>$qjYgfMF z(9bzde;Mqm?KL6ZA!6@y9R)OXn@cXo3K1#fbqk(@GnwjJMYSn2yTZF zw#pMs3eu~U+JYKc66-#cQ!wwM1pe2osO!iW1gjW26Yi-8dshnT6{V^tIouyJTd059Blr6CBa7$XZR-(Iz z@XJ~=H+3f9Nh6><03N+Zh+)2{Bgsh=4Btl-r71d}@m|&50CF!l59*Fi-XWvw`=w&S z3d}~nR}o*D-j);A*lv^in$|~=J9b|>6HW>45&N5gm=;j7x`W+Tr3^DzhXCX1G66aR zi^ojlgkS{Dj_=v`iPr!I?v0F#zc}sE{4oPd+zjQ@j4Z4pr$`<- zl;MaD?oBNiHXV~?W(3iU9>)-k3dqtoMPCGMt#RFkWUngdmsy#Hochpo5qEiU{~|uA zaJzY4ew#OmxD$>2AQJ6$@DqjV%KDvxU!FO5{cSL!u-P%-*-FgG!E~;4$Yx#NEN0Fl z0*q+&yhx&MN$^)a1+@%pI#1g`T%1H&cUQS}=;gCoxy39nCL5eFe>VNc1W%4>(TA4f zQJ;?d`bSYD#(fv1&~PC7c{d?t6%kz@J92|ur|4O_c9qOkOwRcz)8IZFrpatWsrErLUMUv9bRldY97y3a;JjH5Qh6nen~#+)wZs>I;+zR19z05(9( z>TWQO-{VC_<<67-4JV}D$mc5JKj-MApBN;&>b+j&Bz^v*&;)Nqb=R;K26kp(5lVFL z=bWbbuq|#Pobhme_$){Q``Js;lsRd|=l>z>o}wdd+jU_l72B-XwmR;lgN|+6w$ZU| zcU-Y;vy+aEPCB;r=Y799|GCy0YmBvXZ`VdWHR?Xj^SQ45bbvr!b^w=>85W!japU~T z)AvQN&_&$3W9}`kO2MugRY)<(z<-_5&{!^H!{>hl%Y{Ow6!cCs+voJ2( z(5BoBeeR-l4`Vke)phi6*m&{EM(IeY2&iooR8pw{110HP9C{7sf-o8L!yIr+oskf% z@?0wcNye84GIBSZI55zNdP)Xky*jaTl46P|o%y3&8QQF7HVov5*JdtnZFss{L!0)+ zU)IZ>#TPClOlE+Lh+8q^xwmijzBFtdTQ)f!5&%2iW#X^ZuAgJeplQG|9a*9P-cNe(M+ohAYYSWL z%2_=(1^;e|@x|q{O%`QzjRLog8??(DBjX0c!sYN$5ByFb6^uou*#)so7k|@B0e|a; zS03YCsy`d^-24Un7tXBz(14k@WhYl!%A0|s@#m!0mEMrVqsm?9Cz=Vg9VkQBgC^Fn z*a1Bfld?>>jci=!W@6cmT8BD#7ErflY|l!btky|D{Smz8rb(T@ef=^qR$W)$0TP!G z6xW-q@qHu9c~kxz2l&WDIp?v;^UFy%5;Bn%x{W@Kku`;<~GBSC)A!~?m zeFPRRwIo3GfAMVtTSHY6#55!%4iZ?W&4_&+LBtB!bKsHKRZk+bXopwcH+h;Ey1sVz zXjB#^V=G(H7RG?ZWicYXRWAjcaz_ue7a-0$624`D%FJ@TrrB(D8q z>RT@gy$`Pao4UE)Nz3n}`4@jOO^t#Ee)6sv-=$>#+U)HUl9-NqYaa$T0A>}InEUvU_`Z<@pumt>8o)* zIR`9f5kD}~?QswE$*<5O!g>qsWp8d9%T;zXr8q4p?n z$1sQ7!P$?&170G|DE^?a0C%zHz`Pc62JAFHW7_=;V3bFsLUtP*y+|Fn)|g0af}oBS zX6og}X&bkIn-Lk)D{`yhI?+cFP*0Xrz$^-{Dqd{M0* zw7~)n{X@e8LTG3J`P3afKn)gY3qwX%NwcYhf{)hWEH?l$!=sk?v@h2n^#7OKMbA9= zs{fYU?fOs2l@fRTS8~gyHaEU73uBjc{jT zhL{POFXrO}H3+8J45-wtIXiK6aE=lL10Z)oxP^BtCi3supd&o#u?N0GGY^ZA+!u4WA2_*CA?tQLiP7%C)ab6ol}BJ| zG4I+F1wUwEf3;KpFuQw0n0T5JzL~$D3RVf4p`msG)B_qDMT6Z8zIiXz!v`Q+Qgh5C zr0A4_A|S}_5~TaVMaM&oZ5zIRrLD~pNHfipZ!GbUysyK}zb2oW%mf79bOc9UBW;3gSqaJ_nv*c3B9jn^<+=5B3)q=IG{DOmw@ zpQYRvMeCZtoB`i!rI9@K;U7R@D`1n_v^C0B#L&~bB%mo9(SxahT@-572}}w5??0v7 zSjsIAUcm)z>E60{hRND9o%f42|L6xJdb}SJ=EgwvuF4(MESe-h}DkW z-19Jf7U-p&q@Unuk@8lNWSkWyS=^?@OjK;_mQ$DEgCW-A1B^OwR*=IB5BWu^xriuB zn4ll$0v)vJU5WBhBoQO;la7O_A{49UD`#`@Y_J2aZ5EY62;6wySqfD&aV(MFGc>zM zc0#_YrM2$SIRD@xAY`Ph=cIDfH19d_D?6!+$ha5V;gC zy|TXtfU4Ze$hjoK)-m<_iob*5nq>xYU{P|D(gVsni-2lWnB{RC5D;8~gFwTloo?eH z$Y-oO2?epd#wl;#HPcplbyxqDlpz1^uMXO!9h(h)d)lVWZ9q{3`h;9WzW;$-^$)`DFUDY5j0qqESOFoYzb$Gzzyk9I#=Y ze?)~P$gnZh>_7HG|N&5WL8SU zN+0nhIi(#lMAmK;goZ?x45CdKz!qMpIIWn1-Z3R;IQ#74ib?PME4jE+a(!?xz2xA% zHWG%lq;JR=HsF&f^Ph7YQ!vE7fDjE0!VzGymyoI`MfN$|vo0af+rFUW!p7`QYS`3b zQ4TdHB1z-tsX(xdgwf~gZa7X^96V&)XgY*8We!_rA=QFqs)uYt+?*n@@S1_9y-&x! zg#g|L7^OOyiG}t5q1>fZ1N)HAVXV&d-5gU^b=#H2Y6v(#P9=6lk!ipNco_VX*h+Jq za#mI^oG;21vhPBG;`sCGdC;9&I(WspFIG4^l6kZFl&%~Fw+uwr& zSJMXjP_C(aAAIhPP@t?o5(M4Vm;4xXyiKI0V+P$X1=CwE?g>YU`QSHQl8yc@D9Oxxx4Z)DBf}1C3?bj>fXUUgj0~rN zm;5Av!4uv@#=Q&~PnN``4DwJMf%&tC>w@&-y9IzG^RtJm*_pJTl-a0vf z`W5&;n)}(q1^mR#X`JH841{}FHbl-7ky78#@Q-sb%i+u>6mM)$$@Q7~)ZAXze>7Kk zUIpdW7zr92puXGvpC0Z@Wo^~Q;RK8(gV$jZiz}fROznydg_uIrs+k!u^yg1fOUouS zTuU1M(BP+C>Fls7xWCH|lLqd{<~7*i-V_Vuamdk{liy=L?`5JvE`fk2@J5Jn`8Kn; zH^sm;pvfl5jVI~)R(f-30^!dYp*vB-^*8MSw~iHg_;Q61D>zXaVIxoh;?eAyTW3pl-=gZi8w?Iry@IoCY?v3C07re_+RW|=o zbA&;9%)>Ikr89g9hJ%NY*$hUNSc+Y!UxK#oq>d`+C?Th*#0_63w2`F^amwxtpzV)0 z9rJSf#Q!+Fs{KA{P&+!!ak&GZXE&3sG2EwSIZSb+xW9iFz6Y-Skj*j(79QLXE+J0y z_9YA_+fz_XP{Z@;lAloYEQ5S4o6h0{#vYXU6+q9v* zuQ;q?Cx6Gp0&nlSQg4K|2W9R9c54}_$NupR#<;VmgxQZ{`o!LUPqc2+KI!pXqkm+# z>!SGAhLexb!AlP3M5}#u%pYtBFazq-EHtu+uAz#M2W$uc17Om$nXRlfvM~ z_&v(li-Wk-%C&oBu7Mpl?nincHddZR?-P}=xfC3IecZ5#^RdiUE_b4nnAmLB;4=#YX;_tZ;3-?9OX%e(0yrHUzalR zXx}lD6?cLTT}6>EZPTKnX%Ja=(2oh=>5KV(<3LJ^f6BHpRA!JrGwMM}vQLrMob5Ym z%q>tu*G<{Cw!xW}xYFv-lFq;;;J~Sj;t|$XQxc;NgGIf_iEy5m+UZ?12TT!Urg|O)Z!V*di;UgC;|@eo^oQXsF!z~;5y?c%;E8kM{scrYfv7c z3F~qJ$_~jCK>v7d?XnU!l^56`Ytq1qa(|K7Kc1^8r^|}QENeYf7(&lVtvP>h#suvx zEBvhs{0Fn`7ep{p*E!4jW;+<_Hp9!Cf9kjlBtI-8Hr!TDcI$1XZ+x+Rk#_Fd3|F70 zOLt6|i@=|}%$2p7{(RdKpj}F<7Q}!Q|)bq0OF9U@G_SKx?VI86dgMGfI zF|-Y5M}42a95yp{x@^*}6-W%HxvKnx@^R7z_z2W~Q|MqcNjuFQe`E}n4t*ZWg7?7hVW_Z8}LgDvr05+`0!?7?Pa0Kum%M8b86Ga3` zqg4w*6fpOVu^AbpC5?T{eXSSSbjPpH zcWrwD1wg=#za^Cahw3(hMpITgKUEj4SBwEjD>hcs<8;4H)WvmK;kNF8+o0O8ZGjt5 z@yWWcIcme)4EC&nGj)M-7@vjQ!*}ob!|o^|p*$R);Axb>(1x7 zdCgAzll$SkhyU@Vxaq~hZCK5$4d)ax(1q2_Al1{TX(*fjpGvM`y%;Lu5+vlxh&8%) z!ule49Cq!?K4f~L6MR@()~uZQ5{o9pHgK4IQEgj0_z@}Gawyn{<+{y+OXtq|#v6QP z0>81;c*M}Zfl63?-j|0eXsihhY(%HDh;|LudOIol0*Slt%Xcp@uvUh`1~*fG9{Sf4%#WX zdrQzU$Em#U!|vNR$Y^Vy&bUhKCri>*&Oz5&Wb8F25Utay&a`1_D~HZ{Ql{> z*V6xS-O1z1JH^K-2jW?BMUk;F>9L{DR<4XBdxyR$lJ@)ivc3~`A>+0)$~-5SytZO9 zo?N|jFk=+|RoFWBBu;NDpEm{ruBc^0aotb$;lKaZa*xRCLaggYkzhw`cRS!&_7w0z z*d16rsC57*6q!O{`?R{9R`*x22H1aUxo<&h3Rkr&dRq5WrlvxYcgyds%3POSCeHww zK43~y=CcT72iL)@<6ndyh^p+CIT*%z&qahJ*i35Rp$p(BBP*w;)K#tq+b(#--QWE` z7$yDvRiYoo%ekfA>Sz|W8vW!E2zo3ta*6rPwzvPS<*sD0KI+F6=GBEpG+!kKX^H@D za3Q}L=>T~H;;({yR|B#yC!)tvv&EWJNwk!Tc1jfxWT=Jjnq_|7q+$W;>t-?#Td9)v z;{`Ep7B!~VTr1$6a(x%ze*2GW~c1@b(|2Rm1q7UBQ9>t0s=paQZ%n7XtuYns&?@)SR4Su-V4b7hEZ!ZF{<*t>J;VP<^?d1ZS$KeNNy$l;j`jJqPo0jypnMIM=s;dhf>g2RH~y z+0Uom`tYp&SO&lCSjv%uUx1!_9SW{=)m>1nxN7lv`c$i)9OoXPi>9NiQ`UHPt@ifVUEcW zoG1WDT2xYDr0Z5m)2L2cEKWY(dg1ZvZYE!~6xB+;9}~}hl%#64(SK;xt_V}{s4A?R z8ds*M&7qMP2z$QPx-Qc^A^QOAA2kZCJ)JNHd#B_NgdA+JiAn>V1Zy>AC|?;3C}j$5 zh+1v>B!iAbb6|?CZ^9$xsHpw$ZMusiKTv2@UvWw(^k42)Yy9Q6pOQ8%Z41nON8Wlc zecrk3FNw&zU1LAEN1g}3ZnYO>Li4-w9OdjCluB3aY*Vb3W%d-(!&D09O_D0b4@4Q1 zj~0XP$FGMqsisv-zx5$M&j%9o!!)bHJW6qfik-oCB@+(9*8ga#(aiiU@Gw^{FEV={ ztNFgJ@U7k25&Z@N=BFu(6tYYMmx++bo=Qilx)G!?Qd-`hdHB5Vz5=}J>eMnXkJnNT zRQG#-Gt5%qBw=*<@YsTZN-sfAUk$p0UF=Zgbq?oA8g-^_V|({=b#8vpQE4?GbJF~* zz0F1*5OfbkBxQ|NzVU?}k|RQ?{1$iV3I=z~@)}@d0s84T;aq5L7w>^incbvFlr{vg zP@<)8x!o}#_3XY<``WDwO{mxvM@*1cUZJB zVN4dO6l5-NL}2(JRxxYh@S7h9XNawIDo74KHmqbRBSQQ>q7Q3Ej z)y=I8Rnx~SrC3M4ak%yST^$=Ph^1v4i3h}dx@x-@tfl@8FWJ(}UbPf7dk~#$^eKWK^2aL0zk=Pr&5dVSNBR+9WlSuw`53Xu2iIc%g_Soqog$-x6{BDlIQ*68%1n!~Z7xp=Ti0B%=aSzQ z4s!?Ilrds;t#I@+9pXJ%kS-9q%&cI%b!671vjwAdiKffi!aqa`@p0ThF*w0X{8v|- zZ2vfW$tPwe7w7fTLR&sw8KA-=)amE#5$`*LE#FJ01OXa~be{bW_)J4iqZaJzo`X=r zHwu<#s*;%Pg!b;`o3V4B>&H^>wVQRib-H~HqAn_9{6`Xfuv(v2VB)HbTC3o2h+zcN zm~elyza6fMFY*QLb7~QHsVdz_z-6Rh2OGc-u*D(I=ODv`*`E8%4?9HcOe`SpDDVYz z9u}CHIZQ~__m<2hsRzc{VXN!)jGmO<9GY9tB;5fdsCaH3XSfjUm>$O&$o2h=qBZ?P z$x{(6qhe!on|>Y>cyhIIJoNQ`1ufKPOKwM}xNg%COCne!k-5pNRhiL}XQEgBdCL^w zt6;Bxe%k1&;d(!d+B~Ob*7~_UgWmxTbvZp)!EAMoj7Fa_C4Nm<>*8^ zF<2s&gWPX*?UGaO%YX!-YA3gCsYsvs_Zd&M`*$aN`j=lv4RY;c%btwk6DvYLH<1gR zo2A3jI;B&8q+1(Ls@3~(C_sNdNJVuq2lgZ)FlETJAApL{4$r#DjCeG_tzWW7P4Ox$(K=%?mq}(`obb$F;{XT7^MqfNuO|%%G(oJ5-FZZJScf8E3`-Te=`iW*glL z&tX|>PE74l*Lqa;LQw%z*^=C#!IH|DkIb@@YAbVj;+X6S1C3<;Md|UKKf3f#3+MCW z=FWbF0*un3y}_bkL?=2k^aZVHcNptOe>iUAmsQ~k^NsYx6+g!8iL;BndoWq^T=&5H>0u-i zcuCjHiwxPUus{iE+8Lq*TR>28(`oY8h59Dw>Px*qrBh&9v*zkKYru+uSf}cD)zSukQ)qJ%WDI$6fZm-Ki7J%z9fHGxsN+ zSy3CDl--H*T<@dl6B!d3@;9s1X75}c%?;Jpg5-sL3+ttXgk+b3x?JnCUYW@HZoL@f zKxff_M_6t(rRX0Fq6~zS@Inc?0AAyG_6qJ$Q9is9Nwc=I(O7?N9_c3pinbv}0q~ML zik35-3||7=0k##(-)JDdRFExFogo%6=}n77K$_{Fl}O7v7@Own>b63!U- zp0N(LJ&dRFNv@yw;e64X5w&0qZd!XPWK03>c{Y!*Mz~$0_S){;J(*8gH#SYK7U|Bt z-^22{!46F7pm*G7u@H+f4lmPxFVF(<>)^{y>&&d^%NgbCDw^wIc`S3_@h)swwOVbU z3*4LeT^V9W{qCCCFyOeUFW)rFyG_ozv4{Sg!Q{lUlrY@*3lH~|-pl4n(23`EfrdJ0 z_M-&QJFBK`?<$I0a&0XN3f!Ulx4mKF>N2iauYl6G-N>H$oi?daC;Hi74}4h%Mm~&rEtGvZ zTiO$8+G*NCM5Q+!!X4o%YS2QBc8tkr={#&#e`z*phCksH4wb3fA; z0Y{+(|apLc=%-yEsC5dXx)Pc?CHm#Ive|}PZH|bLDec26 z**#K(gBV=IRz!mxAryzA)rLLu=K&=2%Nb`my%ElqiaYYS#jdC~|i?9dDy>~J( zA){V1y{S4Lw9^7_iB?kWaXub{^OMG=7}v1M04Fptk3>v$)>$OEi_7ML&)c=dV^j3S zl;G<7&H)g=v!Ku4#NzVs+O((K#b5O;ilWUK?d6=K?E^cu?XT|qZe@g1PpVxTs14+q zL+5^XW8TNfcPYsp2QOUBx&1A5(lD5ns9Cb@<;cOnP)szOM3FC%HI)>BWCxm zfd=gfR8Yf9xt;+3NEZ62I*$trH*$o?(CHTP|5&I<2Y*T5zt>hqE`i4ib@#VIn4w) zr2xgTFBzOY$mom<8YR!5EY=z+S|Jd-fBdoeehO2{p4Oly0l=k$OB@ag_ zmFXr1CTAf!a}9018HXBhW9YI$H8h$nkZk%?`8k3R?h*Tv0nZ{> zDMIMqN=^i}daI!}RYU^!FXU^*5i%#LPz(%M#?k!n+FgMrmHRX|%L+xDGrba!Em}c7 zqN4$Bc3cVts@7P$`t%kzxNqO_33ZR&ExtKy`+e1V<_c@-fQ9(ADKJMjdQX5=4;%-m zvg%&GLgl|;3eB!(7f%RuT*D~@TU(&Vwr?5FF;iS6A49Dh#})Oqro|w=EeMe zk@Sx@@t${Iz9kGmO|otxRhu1-cFV7s6*VI>s>msETAl|tD(V|dCot^FAA-GPHWKsk ziEHHTG~(Xye+vU^n3{K$-ovwgU<_bH_{BK&Qwd8jzu#k#iQ`GP=8rSpJ2~1g7YS}O z(k^8_uc_&;{*o@noX+8l4g7mW2wNa?o`8P7Yb^WcSY^$xzrbt*&^xAZ4?Ubu|E7}+ zk90Svh&epyk~j_sUr`V0cu{HqeEF-`9(em7r;b*Ee4TXzK)zQ|w~ZQ8?{i>DjrsDB z*jZTpsh@WD0hz~HY>nCKTX(>u>9pzeiA_gkW!}9TD%LU_*mW;W*jA?Mv=5I5Dv}!H zlTLM{V>TFl>n-K@g4tFj;baTT>oN_b4i*U(PCxD?=aBp=UY*PBtLZY=4y!`U5FvJq zQ@ptE+**Oom_StBj#Q>gBNnKdGq{BBJPKj5BZXAZ5S}SW{vc!FSCfs0BLPwX8yL+G z&h+x6!66Uew|QwbdL4%u;eZvBhH)K-Kk)ob7^R63T4+o$LHZ^ePaA(~s^5A14qza3 z+7J39b~%tl?N&)ZfrmL?>)p)b!E(Drf@QW56my}`ZH8&acUD~%6vJ@AM*uuGux?e> z(T;_}!^jnwk236F@-gMoS%C<)J>#8G)|NW=eqQmbH$xI(&X zWY}m|szc43Mmpu4{bH3cZiT(cZjGG0DO@4m1@JQRsTF{HIbpE3tH~HwI6tWWWnZFW zmzU_sOTv|*%-iMzi5GtrXP}_M6LK>&uwt1IpwxHDCNs7I(>+JTf}P71;)~hit@(1U z|MB!d-kDxNUpdufOUs?@F%a>w??Bc|qwBAW(qcP@!+y(TC6rm8>5Kj+P+YZT;p)b+a=&dc$+RNUth~|IHe9oYFRDgDlT>D%I(zNT zqGH6@S}{5c$2=Gw4>8Xr%@18~2zHwYmwyS`z|r;46FSt?!Dr7>Z!={*DSx$yzCF~Lx zHP}o%11)QG)3eS-OC`n=4^ZCGuAN61?Gj|FwKbNbUbhGTm0hSR=e@AelQ)^#<*l^_g4pOial$I`>Wb^-c?fidb)bvr8ag{*7)(9O>?p^QZ24v z_pQ+wd!#T(2`$d$j0oPCfFy=!7AtmRaKg7+=L52Gn;cJ*@hA$ao7*MVtfK{_0I`Mx z{@{F9E^}&&M^N0nbUWlHWdgDt9q4|dKNJ>^PdVxV-X>w&6(a=*=xRj1$(&f@h7NU3 zL`Pzgs>@Qe=5wdkscOv*M~F4tKzE{ead7XJukbZkbl?E$Kp4c%3Ql`U%9y-cOM@|- zx%29u7erU&mhQc{I)#_rr?)nKx0z}N}Ei~0htxnLYch5pN-)5}Y%fK`O1Ge2tZ zB64AXN@-w3^UeMCFDWEBnPyrnPY5F_6(kx6xYgNfuu{PO*N#|YRNy!BWiWhj5_+WF zi>RD7cbaoUqE3_ySIL7M;|T6l590{`$?lsx<%Wy3IUzi1f;+N@0Zos? zv?6evA?vW$Hkr<=4r9tR_B3{RBlknA6Lms*7CZSC#ge}9t$k>943#gu_ZHAxvnzKV zIKWOf=8lnjanp%%PV09LS9g9_dx3^X4!zZfbWaBc$(=5Ep;$3^BKkVR!oR3f?ZO*6 zc_#b6Qa0z)*MeT>q5$}@Uk4_RIhwE>*HNoKj#UxW$a@znl#SD>9NMvU+W-7Im~OQq z0F`Xcx6s=fu_9caK>fW70mpJhoDVP1V2H}t<0dTSN0QAsyh+bW?O4+9dIK2|@hGwL z4yjhvur>(}A8T&_l!%J|ETw4a!&Dd#@qm?bNOExOSwd#}n*AhhmHeeR6S=z*<%vwg z8Sb0RkLJMz85ah|(-&E;`TC(c)aiQ`GqGmxiExTz2T#)=jd2>CBb%Is#5s$+j~?QK zJO;k-( zasRy7(A||S=#RuZovwYzU@B zdi34)qU<1M0)BZEV%$uH;hvPyd;ofcW1vG*QjmOjq$rMDCG{|{F?vzBc~jJ<*%FXt z6qn4)M zdYGNjas-Ea=*~7;6F(4k)56KUR?KRQ4$4>&n!SNKj1MB0))sX7q$mjy9PoSGP_HI) zBh?y3*YBejd>143%;obUf=~@(^@{tKx>=g4r26lpZ7YNsbpNg&L5SuFd>`Q|z&MJ< zwJEyfaIN^VUoG<2^)d)))_ltXN`U%XhF53Y84xkDwCUzp-RjVHF?3Iy(Ej(8IH8c_ z>5K7G!P@T8Nx82}owumdR*R_zQ|uDcla<$2O^5@NHIua-^`mai8=IXwwAdCOg!`1$ z;pY-E(Kk%+UW)jp24 zLjh_UgnhTXIMr(O8erIVc&$qmfuo8JB9t-|{0@x`Nwmzb@qzupk>NLowD&|(G|b?(u|`mP z-LU3E6h)8M!)s+%-q5O+?r&eYD&rsvXA|H$qxNDto@6MyiuVvP@@sPdH7-)qJVdyc zn~CAWygLT!>hfN}qcMmyJs59a4oi6Z1lsS58pI{zI;Q*4O6RUv=2n~Ai0Qe+WEEqL zdFw#{tFgXOM(bw|W}S z<>^L$3^(@J(;w(`*5KWp4+?!0UHPuKuH1$G?&(nPWDM6>wVLi=I3pKnaZalq(WZhf z`;9E&O(XMD(F5Gvw%1BsTPq4BBzq^#yQ$gG3W=8owVQM_UE-5V<#$+q=Q$3y1c$%;V}JM#4Uu#6S#z*)Qh{a0Kx}m(Gd!z#_(OJxD#0yvf(d zI=RQVQ%K746F~I-l%m%Rs40(A!t{#9+bZiaV#4)GP2V5mClwAyh^!UCphEYH6|I9) zS&WbXUd2$(bNWsy-&+O9%fo<6hqd!>ghJ7e)RXosSrSu#En4H~hJGk4`wFw*0tcmq zT@M1?M-JB4=Ei0R8?=M%nuCdN#;N{decR)KSoOb?c+n9C<`3GjL;v0EeF}s#@;L?0 zf)|{32=9h|Zb}YsyOsL7I5HpUR}-8@Ovv4BI0j7ZG#sl5qZDG$bl-CF6=1$Bny13) zxv+e{a%9bq`opQ!ok{%o;>4f!CGAU%Gi1&5lalkMRl1Ye!S+l1K;Jj@oS=_!2l)~z z6XF=nrE{2bQPc>=VH-#}MjOmlpweQ1Xe24T6h(_gw^BszV~wYN5$2B<8Q zU6#vxDtpMS&U)oACE6;C$aXvAH(xo^J(-E-XZm$J0`bv&Q673by*fv+_N^gwWZ&r= zSg%K%Rb{HmfF=hatF*1%lRRI&9}ppzN;=f-GVE15Fr8sHsf9B0s4OK%^z=Fp`o5u} zCh^#v6f9_kOoNyFzJaV+FeUNX|Dt`R{uJbR7C*5$1DG%%wXH@KCrp=2M&_YIReUXW zz2oKMNhNe28BDvcrc?&sS%EN^Ds0z)LO=-}RoT;UxnoENikjiXdj><#4gv=P`3>AI-PyARSE+dM)^*=gU6KeIdKMqX#<4*2%CTn8u4roYI z;y^bOwG*}66j+Oz;lSi|eh@*s_;+$_@2V2Yv^{-TJgNw3|hnY|A05}JcnKi)NtaIBU zp&)Wp-1CG@mW}AUB952qK?-g`xR0^FamGTk;h^ zeF>1?P1YmFGM@>s9@o=BSEOXY_{p&uFv)nEDF+}1rmN(u5Dk3y9&m* zeU5VJd1rp`fAW97cydNX;zPGTmF2SMxeg`&7~2{3d(rd#@^krc=$H>4dX>49fXVK| zBY0ODE?^Av%{8ujvTf26yM9fb*&oAA`|UJ%M2&TQ@kdl#gTz8gAJ-mW2`jF_W-K54 zqrN5cP2Vss3)Dymsf=p|51z+P_)fC6E{)VYf<0yogNodjdC@g-Ka6OH_r16K6T8AT z?%S`Qx#})#&PW8YX$+xCj9r=y9h{p4G@w%$BDv~i=_DA&x(Qrd_OEPb#LL9AKY1iD zSfkR^v&5l3*%g_e?SH})1hq_bPZgm5vIh}wlHkEuu?$%RuVd>4kh?bZhYPv`}U5+N?s`WmnYATdw?-a$-ZDutq7i`l`#OMC; z&6wBFb!_q>jks7vPwOJCcVDZcL6UM4kP9~#8;i}ctUc%AtcMzA2+(gtoGqeivgUjI z4oo}$3_+7{o?jzjJI8}@LsB)OY4RcV$R^m0yHUYpx)wudo*dfUH`oIgi%lYoZ zjqg@u$c=wLrnu^=&D!<3M@L`gqo2H`heM_HQSarj3eIgyWBT9wJWsXvL-0lHv14xE zU~%@{U3lw7#>E)i^fhLJ64EBD!svj6vxjp6#yX2WNpsfB+CBm5A9-W z$}pk;2dxc?xnWq4a1!(c_Ig?DkgUW8JMp!_U8<8>F3hI3FyZGuVlI|F_2}poXlSI4 ze=?L^jf*z7;SH#6>hIO=wI(*TLx|3ncHV2$0Gv;x^iVTLEhz-U1Q2hm9AreF;GmI6$OcQ(j;{9f{ zcBoYuw8a^vz_uuvrL=3qn0_AUfT`lUDE{;J(yu}L>HAHdofwSIgId#huO(*f0{N27 z*-pQ+o87zmgDK?0=pn9!OV4cf$sX5v%SZp-hcoK@_%8~dabv?wxW%QygQY|mY_?h& z(nV8l$v_(6<>2V>Ix2}^e@qG{IqAfx3`|46VQ;W#4(lk~L=Wrh_LwHT^v){u&#o4S ziO9A1ee9NzuM%4FY)8{6D(SRrlt^Y>#Fxsx&U+SIM_q=X}Ehcp+DX7d-}thk(hS1|-?7WO`1I86ovwn}E^e*NvBIy6A;jc@08&S!%FF47&syxwV2^M(*^BT6D!-$6 zE|KlV&LK*vF3VwQ@zr}hs2wQSvC{w)e6h;hu%BFfDf|<|c`-h8$1KKi4?n$c<&v?FOKT30GHcxaxLFo%U%8w&XCHFdi8RTT zwydhMh<{*!R{yJVgO1!$&WlJ5dO_yis$YH>tKathPlPfttmoW-4hsn`P;RVVW8)99 z+t6&cgvehZtlaeE0EtZI5%fgK#X^<3WF3xcC&PKbT=riRnscr9{S%*b+4S8o{w9Fm z{mlz@p0C(!HRWWeIW*A#&c>ktV^?IA>*AB(hqH9v%GdAyKu?1R>VKy5Ao`ncUF?&e zDDqEy;{QMK$!+KVBR&ZP0skvL>5=T4w|>zn>7jh}SnR)VLvFA;n@|UJNu}|I1%7j6 z31P4EjM7{lUOpOyMo>?!l`b(hBh0GBpb=cc&Rh|-bii$*GscT?D1;qOghP}q*?|UE z03OYAbmj%c$q&TI^IENk@5azEZbi>PfVRbxX;I+-5Khxc!Ia_Md8^q=sgAmiWg#G@vdjc<|x z!}8zogg7)LuM4Uo&~smNXhV*a2U@Yy&}mx@%1B=6=2hx!-a>n1_hwo{TN(aPQy@rz zB){%58gA^C5S`pv@*5;}!Ko^{OllaMHIbWXB-B8>w%f;GB!BleYlGEUG>xwH1`WMG zp$Q>*g;gm?rMB16&vakxx8B~44^f^4dfhFhg$;e!EJHk4fiO3=K^-D(Jmz9AM~!MB zWd!H35L(1%ecH3;gkW7PaWuHPXL#yadjW_e%U_Upq-YwD&(BictlhECvz@E2c4;c- znpl~_@`zQ20$2)~H4W5$ubB7Kd4hg-Ucl{$C?lUYh$CE5o$P7m!0!luHUBjXuaw71 z_cxK!RKg`+1syC`SkYXyZ_~Q5iUpUm&W1pLYgyiQv;kK0P2|TZAI7bn!5Q@8=P^@y z{5BokRb#xF4pL{X_xEhyeCi_gSL`01TSLDWtN=QDx_RDrCwFy-z8VC~>g=q9Lu51I z7S=2>jE+`d9jdW9tp7o@QW7h1ePl8)EXOt8_uM!}qR^(4Cg9D?ZuyulPi8G?wyzi%*jI#kqLov%b9QVCPd^ zI+IVfIj<$hSb7guGihwZpN@Wu=K{-sdexiDdB2Uy#Z#+(b9@N7K;dCBh`q9NNI3zY z`aj~6U-HERkbavb&H=u%t8qE99H1Eot!Pi8aq(3Um;4fAj5%nd1+1B&zJ)_sL-jEL zo?MUOe5EOnX=!WVF5?kC)E-E%(A=;U1^421NtJ#DnhK!KUnE>sLyUA#zibt*Gj3_w zAl?`*;u;;OV>OTfyB_G3UT@jXh#;-`oG!9{r{GoU{%`JxUp<844)~&w$cgHG5vph-D7lR4X`HQSRHo9wr#Ux zc6?%Xcw*aT$4+-_n2HyI)_D8G(J%Sy;w`^CG1GgK*pJQWG?_<+!iWL zM@#>MPS|UIc^K{(wIlsGrl4bCJRtA3t_7G@{>g)S{7*R9dwO2K{0C0ZxBnk-lDqI{ ziul`;Xkw8+R0d0gLo=tY^BjppcMaGCKb77ou5l)HTumS?^u{b=w~Fz}%+D>+)vBAf zy%qeF!76vebbFBPFeBR5&$vEbaWetqq5zi%HE;aEjsVMVB*`HJjeBJ^LzGvIK{T|f z2+pS?p7}kDdwN77^_r}vh||aOva5Kay&o+S4ZulJ%lj`R4XzlwZSl=`;hzs7g7A#Z zrRK+i3A}G$&wpN<$iWAil0QDX!OFI>P;ccP8%h+|E8c=@jNE=>apbgV=8`VR=-Jwadj@89lnTf1l$tmV|mr( z3zn-Af!63d;4%r6|G3Flh)c%%XjDn!%Hr zFV+x73E0XA7Aae(mB4L4;60mVVYXDV_!3#rKzgdCvhD-?Gy3?Lr4`e8Y*M`5?SxBD zNnr`CSnoy&F<}k*lDmfU>P|4$-4va??1P->Fny%gMxMrO3vQtRuEuF{?MBngaRn#D zF=yRon}?X<*V~-7SmgZfqk!V2w|M!ln$V_g)BlH>Ah_qnaUnd@5}|qyRmmQ3X1o{) zZi$~u-hwj)EaE=bIe$FBN*XabGCF3Pf$PcNT3{OFe0M)lo(DR=d9Bd8KRuYhSN;LO z*l6P!Eu2nx-2G68`}PQ*^C@+(lr;_11LKi(W}%27bYEPz$lD{(_Q1)w+mX6=P9|;< z5l6R}250HJ=~}32nk9XIlpq{Z|CCpxqfNkSw*P`c{napoCBCE9Y_HsXLmhs%d`_AT zlA_J*C}=uta)tkM3wSZ&A`IXK(0F1uc#~OnO^6JE4?Lke)e!$Hin*1vH9t?(hu{9p zpHVEFj^8gl&pNPGnSFuoiCiq0GEjs}9Cd%$2lmI^g8aP;()c3uH}q~}1;`C=UMiQ7v0G(?Lo?_2#zkz; zL@4}TPB(rqH~IgR6RSP}`I~>_#Nfw2asu%aXi~NRU*u$1?tjRMowxRKPrq2 zK??LkRVmAaSNz`N59qzoo6#E~jAHaar_q6_TFt?)Gc?vQzdx#1r#3N!xWV-pMX;O*3vHYcdu{MbkcM( zA#St9<5le&O4O>X8h1TRo=*ZEzpB#y(NZ4HlCat0uCDdfO2--DDqa#p(E{5nx&8kJ zD6I@q+jj^;6E^<>O8F70S2mD)o7gM+ucU^DqL?!vIcv83w4de3BK0K5mMR9X=UJ;G z0^|d=q~&aRR@?BZIsSNK?r6r%iL9K8h#E7@YR{He z!QCW-ck=KzFN5o1m&YrBL)b3=Cv{|*mcFs2chr1SD|9};%xD!|LnpH8V1zxGf<>IU zdB`>#_v;uIRJV9UjE6ev3vM7~PSk$Yw)x`V5}y}XK} z@<-v#vo_z&_ zSleB6Gm`hl8GrwHGn6$^Ak3J#Jew|?F5~@zzVx{+gfs4sa>V}$m_E9@?Mq;4J_ ztCDZlzauxCs!ZHWVwYM*a`-QXqB;7XhC*4xMvJJp!aC)}|H3V5+A_9;v*&N!(R-N% zOz&=8GBz7LCey1mSYbEEEhco2XQy7IZF%j-D=mQU6cdGPEpm=IF;j5lZGa7qkN_W^ zJUKy%GSgbVGqhLH*&IkMKnvT7rZmGglVSkK7}Aemn>W(fn{~4lL?;225G)K(aNb)f1 zsDCaPvlp3rR%QV=fDItSxzZ?8_MULkr5;GJ1dC=7usMkrcK7PJsyXPla<*Y4^$ml4 zBy}Hs+-;&SwCe+!`ikWFk?VNM@Lde_PWJ7EqZ$eDLbT`qQIBL@Sze}Wcd}8xY~Wm4 zsq-DS$q4R$w*jP0#k=((!dZefh7 zFcSQ_pk)MQ*68XI{JDU=E_E;)1O06m{)(;(1;U*Vc~w(W6&nC##*=j^pMz99@5Vz% zSmF0t9Voq1_eRC<7;3h8L}r+(FGWmE#fF)a>@Mj=EhRdC7e402w8Sm$*tZ{rG`eD; z7g^Wbz2eZ%M_*`r)jxly|Gs$g=fcsF;M?~MGCTy^<=TOF{ur@qX<7nDlfQmv-N!2Jzl<`uE3QnU`(@AJi6@kW zSgshD49Pks_)UG-u@L}r5N%#r>3-0vLqClu7dOX9)WFE*%dl|ox8bKfV$C)F&zfX> z1K;}Jn#7f4aPjs&0?8fIt4trR)7v*3gjd(b(uP;(X&bOjm3-+0+r^~!wm!j2e;S@W&lwlnAm*GYY#2uiUSFpdg!Mj=C4Yswp#N}uEER;CJxugE*j#(YtH>%fXqT#L(l$B>Au@tv?%avEa`SEN=MD=o1$d&4+o@!<5-Dg9p;;JCc&) zRfs}iFBq^2rsxhDy23`LN06HGxY6jGRq{Vn2Zgw~nL4kg$efHWY6$`XZ$jk-V zgHaWXklSRjV3A!T3W-+nI)q&@3;qg-Bef=VDAX&~M-2+ofXOAWxJ+-gLA`KK=y^)f zOtWpt!h}is1$eI@8p~eHw&kS9EjwvweWL3Yu#Ep%sGO#^RRcXSE6Vi47CLIKwvleu zi8qmMI=D=)!vS9U^c^g~ntvE&u0NIzO?Rvc=i%b6f6@|Mw^FyVgDLp>g4h;GJ$bt5 zj5l@}f8>Ykv13nf)h}?$e#cT(Xn10NgfghM2sdqp&TSXd{_kwuM*k`bY3jBxNV1oq zrF@wRWL-zFV%i5fGP+OL|2oKgt~i4|m~@{Jt8E;drO6zRrz*bnx*rev1GR~3<LQ_Q8ZM4N#XwTg91B5S3euZCvwD#yUW$cd{i!U|S zu!U8>tG965(Kcp{)Kx>z?^1wTED%hN^J^3nhb;Li=tvQhRL!3otLla{t42Ta_~t!& zUX+h>8=}ApQj`F3vFdxpRygM5U4NQ_THcW`4Oa9;gX}N(TgJI9IiiFlC;vX8 zq^OrGZv2h*Th}~@HvM2TPV2b8+0=K{a3hR8yEVEepg{ZUiMYGt!VtSC9l8&~e7^kf z;=|K}@#a`*s`B}uG-@)4A>wb0*lvW`U9Hvp-G!*aimf|S{SCfY-xM_tiTngf z2ZRHmhop&iAIgP74s$*#1z)vn9 z?-=`kRnHYgHN%79(pbHk`6QJW&e~)8Pf~HA_#_n`$H~T8yBQfrB1HT?ErwAxi^PI* zM+u=g%mv)!o?|b5r=x+dHu3WH$ebqwI{;Hb;k$iB>Ifrq)0Cl)HL}g(mABpAj6vlj5BY3qA~l?Aoytz(xvB z^gM>fXk@)eCuhIub=lJ;tKd|LDvW*dd^eageY9#agp*XUY_3zTP0q7-c&ClY%auFs zwwao7znoaA&wDpr5MJ-$lU1T|C8k@SQhPHZGq*yXA!^pWk{huyZ{bSBJZlRTQT+ zkF`EQf;dy1E4-csf^I4w)C0{`YHUCI<8chcuh~(MnIxI=h^YjdY8S{b_Jlze*x@hI z>l1_C*~RVeRoP+h>VFA8c88oCh18g8SXn8|Oj|{g7hMVQqu16d&Z8t0C$Q&xT^jCp z#AK0$blCKarKLs}`~P1u<(ibGN;l)M_8n;9PN!0VGb=Q*6t;RWhB_`xf+N);g~K*W zW6%d-d^Pl2X|jF|tMM4Z51p$dR}h?&YN|Obm?N&%Y)w~JNAi&~W@Q8-qtV%jiyFzx zTg&3g8T%$fY>2Dd4Kj+W`zg=eV>e~(@^#>Z?z2AGxzBp`=n^oqt7-c=e3~in63p^Q z@M=1pGr8K<`qEoSa(>1}imS8gy)sP#VY_JBdtOm=d}RvD&r-|61r-)+XH3yAHN=`f z3o5_*W|vpM2E&u*Vaz?1P`8%SLxn8mX}b-x0{TA3H{%(071hXsy6qxKFw3}hb(4FJ~l#4tOI6;dY z_wn%8TD7X=Ac8@wK4`KvB+bDPn)s;vZ=#aY25H2wEF{p{JE5b*6X*UJOHn%(>fjtO zy-A7qYv@$V{0xeZ8`(Yv6y+k1g+lTjLP#Ti4S-UY7-9awgBpAk(#aV8TOVhIFA{gE z*gdKZlfpV58?iWXJi6wu$6k!KB149jEw3>!G&KkF@9XHzlg--s!20LoJlwmh#__T& zlWXCD4r{TC8)W-;VWJCLpY8-G?ej2#*=5~k?J0KO`8k}c^j7_uNYTg}B_EXHQPE=! zh54HUi#a0{8YuMN11U0AK=HtKvthCyMd>MaON#R~D>WZ&&MXF~hbEf#-QzQ;+HG17 zLKzuJ!o+Y#(hZ#+rmx2H&l5B9cwplfn)ef*yKap>_MUW|9OxhF#vS(=MiRRq-3-BF z+3+q5X!W8W^cr!kejg~I7X6Pb3a0p|mT9(p!Eb+FJ3O^prGvUnpxlpMy?N!M3vznORh!WA5CME;+N?(`tnd- z>gIj{#v|IB_IncLf-H;RfEMP4QezRJvl8W*@H%dy6v)jzQ5}~Lfe_Y6odBre= zdtmK6VNC_o0fiSzIV;2hf{3;x+DxjDw?lP99a*9R66m(6_|0nmO9>{zUCOWQa*H)j z?Q9DRi9PP+s0t~|zgc32K9-mDpqJGRKx7!W&*W|wNl52lzS z$>H%rl%;rLLY1#E*IudAH`J05AK=`p@osg#zRgb()%W_L%qIKwJekZOTpMvBAFM*T z20PeaP(hmit0^|I|5a1s{!dNO^>@Xj%KArB<|JbIF|xRSZs~uvvz=nm*_m$ zvce6p-?yB@*ukt7WnVjxE41PwW`Pe?| zCswK5H=={gIP4iW88aR3cFYqT&iZJ8qSr9(lh z`4E`N5iAmf43!(gwQ3HDw9HlJ<7`)Gpy(7oeW?GgDe4t!VZIf)^CpM}&4tI1*U`+^@Kr#uL!h*?6%ShIg>N+W$wCSQ~M z@>P@M*-5}W(lGMxGb+d-`T@W6m1Dmyb84gg6%tqdC;tJYZv5T#E!suM^qj_V2_S)1 zab~{d%o?mkUT1eE+0`Rw7UY@LjL+E_vypemtkKx55+}7;gL|uuMWz|wD`t0cFjUIV znQ{aoCBwc*RggRI_vka1B)i5T^td&o14LJe!_|`3;aE(h(wx&T8LJw021q;$6BDvb z6i)E*-4~^2DAM|Jc=Ngg=eUMUX2&gyz~&@WNktfU!QpYJda!K zWvF%9jPVu-Wd5A3PZWPzH4?)DS@n8xBwVSr66cI=vpMm_7bM8&|3UO^yqrfq(8l(0M2DzcVKWwm zGwxnQ7qT$xo0+~%F(hk%nWe;ZUE&@Q!M&GeigTcNq%RDmvzVDyuWnsHOuuMmVq^}D zJ`s|{8%a19ZiO&ssUGm0Sm5%VdF?_#AKg{Fcy+}r8 zg#*U1#d&lxDtS*($+k4X%m^*2oTFJ3(1(^pk|3BYVYW(GoGsYwexGZk1;4KlrcCO` z_V3et4uJ^G&86cH1(+I55jcT0PngEW&{W2oa-tiBzGl;GBGT*$%BaQA(^~!rx}ja~ zK>8wFSLX#;rCS>!hUw^cAY_1#r}}s3L1D7)OBZUSrv?aw*V9JQj@R>gD(ZHNm-p1k z>0vxV@^2WW_i2HnSxP_Q6j%~kMSH6=p*zvR^nP`LYbzzvM`~JK#HHNxBz-v4SYPUF za=VtYWnhqmBwjeykIxK znSANqz}3UwQeAEH+M>xx9;X%P4lZwbHDKK#3ECD}8x~Ib-OxhdGLhRqG;-D>%Zx9` zdIjsr;BcW4;AZXB`D9tDvZ?Oy_3i=`qimJK1K|mO&%syxa$qPBKmp+Dw*6}=D^dT8 zsrZLoL5O*Y2{6b?R;khl!Q??LIp;dgktWU4SF3-%remah%Q?DSSdpvoo?JDnFJ!su zBB9>AFcL_#K*O4Pb(0QDwe~8Yll$KfRPz|0N3VqDnhMT)M)uefyenZEs z$n+iK&;v`>5~aTZ@4%J3lqSW$$BEUV$m0H0{;G#_8_buCNS1{oxJqjMu4!hp2#ATx7qBd#?-Ma5WLjkfRcd_+d$39bD8cG@2bOT~uzk*yfmJ+mCN8ov*i*l1GqY z0p^V4@myRiMZl`ck0j9ROQYS9>$$~;2|ym17J;J^SeAr$b)|Tx1#NZFkAA&#dRmB& zJ5$I(PkchPu$PWFKAD!U&Wyc$Vyn;YG6N!xK`?(;+?wDzceUbx^m>}x@x-vXRrg8d%De+8tDD=;jR<(*~clWm8+8tB6>RP9|FdH{7eSBG&cy1Y56g6E2zu} z6;I~Zuje{W0e}XqGULhqKsOSM>DuH$7L|Tu4o+d&tcc0wwYgLA{@-h5u4%h$<@%q0 z%HiVFWrn3?5BV{8683liJUj9rT}NFGmlfxy`ioWmmzA;I0gw&u(jRpd{iQL4=V+*7 zq+UN|XT&;be?yRi{0G%waM7q~qI1@6+3~|i(|V^7e^89cL8nY5a7l;%IIQNSas#4_ zU*&LL?WG!W){q4yD1ld5CTN= zxilv5tCy1d6WZ!c#c&g)5IasQ&ph)pAb?cOoMz9X`oaV*#;a9C+JNnFH(CpT^Ub@R zX13K+y9CRgiJ&VuGAZ25&4k*A8x~S6-BehFIP6IECXyvn+JSMxx&vUgM6+pXyC zgTQ4oYvwgi+2d5++^b8$!%*6&gW}D#0FI)IfP8JHlVoXB=G&^I@W(=<_Ntyzw%cno zRskj3&oTS@1=OOZxurpt2V>s(+p|%Ycc9tja)nC*3Mr|6;YNipSspCDL3B6u0%K;gtV^2w& z4cS^S%WP&&HsdB$Bpp9splU(lmtmB)r$Dsy+Mh4&LI&azZ zCpJtEUdMmdYCT1+cVhFUoA7O;ZmpkpFo4q)l1+r(I^AyC*C@9^W-?J7Y1C&7u{|ky z4KZTbMX3ERYC#|s71@|>oHhr@q(nA{R1P`1h6T554CVp=PfT2UVZavt?@B{!oZD&h z4i$+opFwIpmGKRhNaqy{i=D^N`OAAxGRWrLL{6j(1hP?rE0%(66#@SOB|ch`Hn~lp zv4+Q_V8PEXltG~=n*Mr@^YF#thTUF4l_4Z1Le5c;d8bRoP^EddCP)58iL=$vrvrpc z&b~^0skZ2L+LxmeP0J=vS{#$m;@Szo^d_5zmeghmw?xSSBIIXaaJB*a%p{!D+%l-B zIj5#g^tbl48}>&kCx)Xr(kUZOK=(e<%l;BloGop~4rAcBf*`fAHP_b`=jY*aUAokj zC3J*NL-&IA^7{B^*NA%EZ3A!qjcN2So~(pS{%~v(zU2DG!wdgGUiJ$of9t3!En1zz zidKVO`RY~=W=wM)8|5b%#fBV|bWWl8hF53Ye!k^L+j^8slTD(evsZt}E1Tx~mp=n8 zpQ}CTt={4{kCGpehV^up-1?cFPFE{ztLT939fPC4l1sE7YZK;K$W9(uQB?^Be{QJP zq@gWMB22NXh@8z^g_gV6s5{;OY9{1AS1fXMFD4qxS<_^9Gnb2k!$NQ*_r-6rxMZ-U zSnJC5u#NS$a=V_t>m4p;O;w(?dxbCsjVF1two}i}R8-cv1j6U6a2z-RFyQx^NMQ;cjJy9 zBj+4?_7E=H+t^@~NgkyBMpc3;rPam-TM_)M2LZnmKI;%=Oia{KXt7j7cp7-2LBl0< z%G18Q@%MpboTMLz(yP3Ek}|CmlrwM)k{Jv#42HmyCeHI{h(Twv0_{WnO!|f&J`QDYR#6WC9fi1yi=WOm@3BEIhz>gmmQ(QE#mt0Phivpd_ z>W9gjRqT=O8Lh|3`$&G-6~1p_{KpFg+9`sS{_Pc0D&u*My@>$#pwpU9sA*_N7h>sv zl2TrBH8ow`B{qRa1FAFQiK8OT)haKVeA{LWDOO_5c{fPyrpM+cgxp^(iav8M>{(#^ zbebI`bl(&a@wTy<9WF!z4xQ3C)X^aX~C*5CDd>j(V;73n=i?eVZkZab6Qt zu$0dc#X*{B0zShe6R5%rOQ5~omz;9f3OJ$BM%EOfUR}vR%kNPF>yWp&_F0Tx^*bGl zH;sEK7V*RSOrr@SiluS3cxa z%yu^*LI{(_w|%I#6zDw=E@X8hZ8f!0dfK8fy^lR18H|>*@%{*Z+3?$p+?MnJ>Y^ol3j`8t5Nt(iLnozXs>vnW1IjlK+WJFSI z{sgp|`s_AnV9ELPIXa!LRXA4BrMC+V%hqLD#1!yV&90<3d{?k2pLaAd{aL!h18@xf zYH&@ig}FsX)3(3Y7M6ff+Yt25D2eIf`#o`IITpqS@T;N*>Z;AGM6*e5S}HL$(Z&wW#7(f$F|-EJFn zrdDnO8sRvaL{!n&d=aaiFV$3_OBSTgUE^|Sz5lphR*UgL0hz5LtAaw6-*|^0fGf-t zUSg6wrjCvD%R#pK{1rF4#VG`pY%INDnGhT|33M49tdky@vTx(j?xgZ zy3Q_&6&C*xjmEpkLSP@a_xm%c>ltA{I2pApidJ0UvIdet@WKnV--vPw==|uKY$5@8FU=nSvHz-?N z35N1Ae{uz+b!C@pNuWB3;A{kuTh7Vg?m7y^aEM8vx~*0G)9@6Pr3@@vpJ^LvOR;AaWP;MEAd>c1+*fNL+6XKL4%JYf*I ziUUs@XQnWC6+2oPswmu~@5SOn)+vN@omG{6NCmM@75BSHzw49@&f#M=+F3>LEfM^|2p^E&)G3wh zvdnlBjA)w5t1$qf;|mN|c7bhtcU~A93K=`N7D3^ujQDsGyE<(>^mZOZEsbxdj<3J4 z2Wx9fwbr)ONe=aB8FYbHox?2I>t;;Skem}WmCsVw6<}fnv_HWFrH3e{(|q~V?=v~@ zwTRWCBa&OAb|pA?_aIb*AWfLf^NF$fT|NBm++AKbP`V;Y@|PDlQH@EMzq+n{MGdzO zr;A@OPGUi;-+Bqy|5@(@@zf-e2{U|6?FSTFBEw^Dbx)pvxcrs!Fs6LnF2+Zi7bN?| zBxCT0`tHNZkQ(nK#@7cY?Y2pBzVR&nK{)4c!WHt^6j_14QQmyxjEW3PM!v5hiHO&R zL~B|b;({8xrcl-^>c637&z^*-%d1SGe#doKvck7yc{QoCFSiLjs4pHQX-}lk&Bp$V z&GJ|2n}_kX5Y89d*B6)GeR*JYMTVxS78xet`~?N{9LOoa51=n+D&Z*&r}7<$i-GY$y4#Fc%Kf1s$`$`~<JB33B0;7%k43!zbvMjldkC!4s7|9% zfmvG*y_#8V1b<-nE|JU`(q*f%F6%~ZkbX&fy+`}@NFee{CjGrSPVOPbi7=eV}`tbEfFv`!i$>2UvtJFPL~Iz zVFW3G`LYqTF@iD#xO0c8xTRa5yI_ipGp7vGFTb7<&3*GqCH`&}K4JCl zN^9Z{*MNGjU%(#`5AHn=EAH$MrlR?wQr1ZTutnZJ|EY>5c%pEm-)Hj4Y!a~4go3CT zhU3YLd)V9tPwjFABfxjTwjTSSu~a%lYX{t!2wsca|0PW#y5- zH32>R6@TLRx^xaw;Y{AtMCE`H5GvXYb*r~rtb8>vG0(6P_4uVNmBxq{kUkRJFH)!qVZUFRBqOE%~KIJ^5&F=IvV0m6+XQF{X6`a)~`4c*S2u2;3BRrRm4S z8+#C_Va(=)X~s5?2#=f1|LGE-qlpT%?v@@Bd76s^hHU8Yg#B#ZLedB-OD%|OpUc6cM6iRZ5 zw$+^{!0-B6UwPNT*RuawJ9k?22rFWDc}Auzn*%^WwKD1EcR;jEs65S+1)C@Unr?Op@J<=1C|?*T_U zw|uvX^iinlkl>>`y+yTa&S4yV4KZ*$ zAXSn(ar(0k`qX+IKu+y9S)%H<>_A&7M1OVipi|I#;edhnAP0msU4$@t$$-4s54rUkAigCo^!1t-ZzErvbd)Sko- zHOp~gQq*96zkTM@oim*-pJWwWcpMpW5n0*Jfn-k%4bHd&y}uHjP;sPXgn_PRKDdgwTYdlP&(~1_&Sb0nM$vxoF%~?K)=zEbec`nAmk1NP5FhcuDw^oG;nId zGeo}Ux`L5<>Q`(NeH1gwnRc^&cicKh^kiGGH!Dohot{lcT^Smt`<^XB4y_3+*$%H< zkt(-~UjkO8?l12COkWF;2`<5_AuSh8lT&~f-T}_yvxtnrWpf7t$ct-Ptc*yYyj)M_ ze{+xe zO~y>r`_f1&I8*N6z$MBjx2sCMU>eZ0p?=MAs`D+sQqs^m;v&TMAX~NURi|!G*iN=H zNzF6=JcJ1RjAXg?Wh_)~4dEMVszK=IneY0?iZjMx2V4U(rbaR6B5w2r9?GTrT0TXZ zU%T(=c^pDN%sl6_Pb5}+S!Xtw88(@lg`_`UVAo@nCvTOfeXP*(#Trx<)A)g&IgWh^ zf_^(V7pHzt(+NRrpc9zbvqF`D-yri-02Pps9P6giwNCs>8gmfg+GV=IDRJ!)JU5bY z+3z4dsP@Vxkrl=VolS~Cor7QSDy`A>dIe>9Eppnoq@CcKog;K6hIS>pJl+;+HKZr{ z6gLI2#krYU@Zd;WuNruy?e42BPFIk+ZrvM)q3L`(I!aibOX zAFLavGW{}k_r;(0QjNY8>x+)b&8kk0ATix2c9Vo1(wQO8N0^qlcY@w^FnDV{e2#f! zrIIZE4puUG08PVjY`SgkWcP`2KiaiPZ6_n<0U>Fte<;dYc_<>igZ=@^AHXvwmhWuW zhuKt@PZ)x4$HfCo0#~XR7w|Rfx3Bxk1N5UWFYq%|XmNlk`HTuocnyLFp(@ zycI9&5)GIuI%Uq6~WS1X+CVnJQiwOz-4zm1{Vdk0pg+HVYLXG?ir?Vc}Pxuj3K(@$+aD z5h{6nH>`bV6w6^uLp9ecOrJ;~uC1klsFHMW;WQlQdFJIc4I4s9pnl>_W@w3xC@$H- zOBlbOK#OW68Inahv8sdEcIH;x;6@>A3aaN22lGV%<91uvM;>!w8~tb*t0fA!ZlWc# zN%ihMbJgsh!OP;x8DC9~t@NgKePwzm<*Ra>o%#5{zX;Wm9ZILG#s`@CAHRelAITi0 zfvM#|jGQAer=Tl4lbCjY{`dy+{S%&N147lscn126#BhJb2f8&^fzxd&ckfFZMJ zSSBD8S942sf;g?m;jL44gPrQiu0gWKPodbH2`@nkL;dIdie?`_xH&ym+rd7s!{sZA zv=xguGGISG zYoX9aGw{Jm-F%M(5=OKrHT%&1J0*`;JCf(t&DNs4*6U_U{e$bilkJ^*-eiu{P3JMV zUgptxmB)a}@WxG}Mw{4m#`VLde5);`w|=8`*q`g}lhDD&wOhitRCFA2AZ{hycV>mg zKGPB~$3nXRf8X8R1*h7N21@+3PYF zdQ2fV>sw;r!*Mhd0pNKxt@c+=-;Y9(NH_zEdV@9t0Vt(Dtjxqg?Y|L7w9#1l*IKb+ zIXNF*q^6MF(5X8c^jK<^xz=o7IV)SA?f&u$u9=-UZSo$#`bar1K!r^xM zc0EP1Bi#Vl>E3$X4iu9UzSgJIGCk_3wv^Am@lMn5pAA2Bh8roOND zu7iPu%cT0dm`sjj^+k@&TTS@(7do?>Gc}|l9!;Eib>xYuW%JtWUwG`^4gq%l z8(hsHWJGe+>Q0Z{sxN@DMv&gJ{62{dE=v4tRmc|1;7h;DW z#8b6aXMi-rH8{cYL+c46+m;fSzbYjzzQ)6s(XzHWFSp@4uKcT!D*e08ite<4H)HV) z@8*Yt$G5YkI_B(L6aig=R^$fp{!?RsF3T&NjC1 zuYwaXvVV~7vysog1zU`P0c7`*V?-!nMuXanj#Z_O@WfmUaQtNm^d7WDOD~lNZk-+9 zf3Z(A;BT>b!3b>G3okr`m)5PLe2l!7c#E0cO>Hu&kh#Hm4^ zZtSC$StwdOIk=F;NE8^}OX9_)NI>*e-4eUC*kmo(zTWlpy3Y*!9IPwuw0kubNNuV*l>7rGCe_4C0Mtf_Kb&!mHH+vl6zBdhP?51=ou{~ zDoJ*SpHww>i!l5I`(|FXzxD$y_+H&SuFa3|R}~`^X=<^22@=_gI({iU zs2_%KxuETZg^G#!6&lhLh7`BYq)kn#^*)ZGp?u7W7Ho{SGk^lk`8*XCgzp#63**gx zZy&5>8?g2F0t)17MskB>VoUsbTXOiN>2c@o*5f=OTSlZy7t5^(%*JKg*9xaAEyCye zgM@gp!i=RiXE~68k&?X4#Rc;Xn0u`X7EUTpOvE6gDZTbf0T*FYT9C^CpD%nu6qo-` z>Z<|d0gUwo*KI?FVKf4X&xtyjjN)=^iuL@WIPZ!c-)0rfF+Ob00;km&^43op-fu}} zg`#jrn&q7eIgmnF6d52(vH`)vsC9!Ms}Ww+ejrOo3^3_(BD=pd7)oDT`AGdfkaI~< z$?F~6z<=sD|1pgmO}uMApN|CJ5oK?Lu=9jEovTSlNP_?sZ*9Q3&Im~E%cep-KQ1!_ zAemGTWD|P#c(VGul1LWYqxbnRsBwm(eTS@|+m$~k1U7*jZ5h+@2b<&dX8~(#y}odd z%(3KpFc5zaUvmCNzWzP(#hz6qdBU6n`03+B7mV z9@2tKcBHtkTch9YVY}-;`@4%A-zKxq>XulN;afiYyJgZVb&>;r5QX3~m=l`Eh;QQ_ z(Mta5??S5?>0&;QAcP3%%xPrW@#mBe+8v+Q(_9?}6zJrK?Hc&=RUd0un6MVtUfs8V zNAY=fNl*9{1s6gNwf0^ofK6nyaDs3lfaq`~qFc=D1^T~7fREWekT?=#mumlXcfIZ2 z6p(^yx*z?VjQJkeRl@aVe~ zw8H_dddyuGi)ctJs-1?GY_3-7WErgj6%49^Uk`#-ov-1y2%OV<{o;J=p7K^a=h^Lv zXw<*P;*NcV1E@e0j)qVugz2zM^|6+Xe1mdZ=w7O!)1HVJiV5!VN_ZfYOt6CCpoCFV8|bvrg3?8ag_AloIC+ehdrda?zRK z@ZE1s6BW7PwZ*l1uud>X(aW{CZc3_pWU7X`VfC7wT z#2Y348(a4n9BJD=c(~KCHL)|XZCexDwry)BPA1k&Y}>YN+n89Jd7l5i`_}GOS6v^w z?hjqnbshD)&vV7vZsQ6T%YP)KUK?#2{%Mky+jl6Mv3%pXkIU+=g;BS!)uN(G+Z}FJ zomF;i1Mdg$tHE%!0S=+O>TM*0k5hHMt`meGRGlA1QWMc1_}`UI<@fNnyUb6jelI@? z9Ve-;_iqiyco99 zS?)q0eO3w1Mi=Qe0+ScE^|k(rDcP{S1tmNw{gJj;Y#`sz8kG_ng&Ntb7rp)4;QCn( zv47a|2KK|EZcl?;!PHjgc7~-5@;|N{x>y_)*3X3ly~qlg)V^BhDMHkb493D;9^&At z*YCQRTScty4QY)9IBp{?(AEUE%w8u!b}QJv+)fLi{;x;z}Je_6L?S0D0>!~haVYOW_Da1$v1iJRm~sV%{W z8!l%^{^>*eOo&>x+_%@*#Gk_hn5_gmI#EsJ&}-x_88B_MI5Wr77W)>)Jg5z|Oj5nU zyMl=b>-7x~Gt)50xmM%hDV7Ly(5rLG5)oE1dM`G-wBT#!k}-q@7@gJ^y}LT8F}%Kx z;%K}ZJKodto%KU&KCNYDOU?K?Nt_@Q=%p3SKk$sx9ww7o@i&Wy$3CEQP@soCb-|l~ zze@lj`o;oo@+WVw60mfFvXm_N=!0N!3T;F|(6g>{>OEvURYIxJI}XZOSQen;Uxk=YL7_j@P??tX6a;mY{P|! zdKn3b>bAOVSCQs`j#}hQF>?>VsesIC9@c$e|8fmGPJvoquUSvZ^%Wj)Z(2P;*^}v& z->Fy6>CHEMj2@w3UH=7Qbq=$I?fi#E+_3SIUsRR=@6D@(q%EppKqJ`AZS9*5tee+L|8r{ zQ%l^o$r+>;NLdgB>aaVM^?4T2kH z80-08KwYKMEFp;)EB(vhngwXQ?Jr&X7AnzjUOX<-S)YLKB}^@44Vja5w2 ztJbxG4!+=15?Bm3$s9koFK(KE3PT}vz__yK&551VSZRnm7>)H%*(&xB!SIl)lflx& zlbeQs8-!R3No+qFT?TevxIi2*akJ1CdRUJ+jEv0SXp0{jxyEW;hMyaubq|{;s@Zwn zD*v*lT5YJ$d@f-Ygu<#hhHsiu)Io|o-$77cT0-HH)6QJ!>kt(&$ef?RGvbDhPy!;B z?a{)?!3iIosg(WW>sg4z{h)hLQU53P4sav}!8NyU&_`CkKi?>u zGRox{7M;53MC%0^wt|wZmpaF4ERlxQa)HPf7yDU z%QDQ6G(p&$7Gel#%G%Wo^DznNUF+hE&xv>rnZ|IPEcd(7E*Y(bu95cHnLYF7Rs?2KHX z9I_$8^{=e;(o9&gw6?XCew5`s&`bdZ^p7*2tC?tIi(5!NZBy)x@7)^45A;Vi>f1r0 zidOfVYn(6NMjaJ6oyx(x8;ZPEp?sxnGDEMcY$5dbX(XYMD(i0jadOKoVvG40V1yD8 z@um(H#?DE)*Q6%^< z!q78XF0obE<=&T!xB_Ks`?5XKkBd#!N3WncoV<6(kw?g|hn+eHpZ>S(oz-!Et`6>S zKa1zb_LC;9l}cHnPUA(MUrh2w(AT_9(JKD(WWf-a>jxKMclGt%y5<^29zidw^Dmb0 zA6Mf0##Eqe#A%=fX6jiWdZ%O54?Rxus6sfL9w9>-6@@(Mnb=uJB~f3{Ff8`&e`xsf z1{4n46e(l2BUATK{T$x=35efdgV*(g(B?wi?iN6aSWY>6A!9XQ^>Q(XN5acNGEKbF z?h-5)@52$;4mHS>uSxhL2-}FaEq1TN{%>y{aI#QQWi8%L_dySi=51V`T&~cyn_cI)tR9&UEXk~t5oua zX)3Z81AK5P1I6-Xqs})i=ewind3#R`Lg3WN8a;kF1?@ONrp(eOB=l$Tzd@O^b)>97 zx_2u^Y6EyswGRPF4|5Va;g6LM_ztGn%;eaO#wm*&hsHc+hmgWh#N{oxAP;Cmek@Cm zO`(q^pabwzcK+`Q=ufMBzvbeEs_d`dPO~P6_11Rf*uJqdUfPY|=^f#0m%+$cf!Ka( zuG+_6&Gpw^MydOc<_;%g3)q=Pq^K;j0C&!Ftd1#~FF|oJ?Fk@|mPnkPwxzH@`F~*L zp_gLg6FkbSHZoj>tzGvYbt) z_bKB5=F2o}^ylmfKeAt41*G4_UT+aH_#uIfHl}{0H$3o1H9QD2Je{)kvqQ8q9+}1W zZF+72s932u7EWtPCMvH50j5@FDIRrgBY||GED?T7hxI?goUN# zuDZZ(0#B*j<1QBpZ%kU`%2_X7A$r@vFtwfI<|{gbKy!lUCP6`{UBsVbk>3KhO!LlJ zU~!4O$d$Z`-L=rC$HU$;l){7pGC5nP>J58*RDtC!OE&b!eBulzp-T*`MU~^0R?bZd zpOBj+5b_stNfFi|2wK;iTCf7_#PsoDUlXx+aWXfLUKcIaXK-w|v&T`A|1z!;u3ZB{ zyAvXN=GEl{re9H~NJ}#i7!QvrUlnsC&?Zu5Pma&RKX?W7vJ5WU(`b0#HE3h#b+F~X7PPuMXf}7AV9DhtjjqyNA>7y%?D*+%cBUHo zE_V<;4uF;tWEne6dI=aR8ppC)HB}&Wb1d7X;>TjGWD#H4d9S6(F5EBdohnqPHdLUf zh8#B$p}PpbD*%43R4h=%@`(Y8?4n(6&vdJ4Ff0zPOHzG7j%|2qcCK#YPL1PnV6Zh5 z1%6u(QC5)f(b{Ubut?vIt#fsQEx?+$Wnb)3sRA4pa1Q$rI<0@Jtr`=UE`XG^XcC!9RB!9!auyW%i_xxh`(6Y zI1M1-({Z;9{&ie~Ct|r8BU22EqsvjLjr`6cX=-1iP`gUXtQLS7XiZn4#kq12BY+s) zf&;Ke)I|((^|@bD)5H>$&(?FLLxTdiC5sSJPb%5F0)+XdhZf#J0`94cH_`>F4&#Sy zJ?)hmPS;544s0)>Z2~p_h6o?i27%607Gd~NS`msgdW^1Kz5%LqY(^`9%620Qsi`mQ z0(uJ7)4Z-(mCUi3Yjt4)3B(7tr)?d`a_Q=`?xR_7VlyLZUHdZp@$_Z5vpVA`w3a>N zjn?AWZEY(8b@m^}WqmV>+V&xNI#7GJBRpoGouyyn1)D!xm-nFwue{7tz?h<0(?NFU zC0I9LoUzqX!6|^@_-XVok-)#72gja9s>tV@^#nVg4sx92zsf77OSMF?h9+GoM0|h= zjPc^?D#JM4WD4|2{*_gkewzHnrD7j2uw6^i%54b!dMhCAY{QF%y@TU0Fw}LB3;V>_ zGoxJWGns_)^il@CHxpKdt^PnKg7BL+e|vQKgbO<{l$6RwKo=W2PB0UaandEI-B+sw zBTMZk8{5myH4V0H=UA8-6s$Qi)J9bO73`_qZKO7fK?f%7I~Nlp`s>_kFpBw^v3QlJ zsuigLy}n_$uMd20e-=kKolh~tv zB(Fz!9fWVeJDv82#1LfO3@{2X?9~ljWApK0ptF;7+GqQ#UdEYjrO%8K^kpM8-sN7; zILzCo$ci0VhhAGk_^#8b#@LnFy}oz?^l(L{k5)PkAs-qcrMnn_j8=+8swqJh8=E># z9&u_&HfJ>!ox9uPMc?fbLSphJU}d~YEF@0w1j0?*a|B^BtNhuMV36JG+`E&k%L&(8 zbG3|-`zkB{NG2jH6(%m%sQQ@;fc@A^;X$N|!+6hWX8jA+g8HT#2q8_Z?5|nn3x$DD zHDG^q0oV)o^=AO#`JLGd`|G_2jaEy0+b6qm-_zmlLI|l5NZ|u!b@h+sj{cA38Z=K_ z|7*E#fqyOc+tGh4H#m}3XQL!SP<9vHj~B6gl_UExfGdt=3q|^h`9{X;N_2gf+g&4 zp@|j+lw1z7dBc}+2`t@X3H=%CD zQs}Aj9#0l^GgxFheHRO1=r!$%@Q`{FXu*67-~QV_KkZ5W_T6X`P8E=as8{gb6zZFh^b#`;Qf^@|5i zfG{E1MUx5SkRrub5^RglMwev!Z=>t%3LGdD%ov-#2LEhyQ%G^D+C7r+!yTn`S2Q~7 zZV=AH`%vg;V{HyR`lL=a8;lA(GAA+{-@MK}7mL*^dvDUK5oA!8k8!N!myO_I^&JHE z${))ML+`=}VfQ#)SHD5vcu|%4ht3a7?_dlpvSDhKX*^Pu9>h7ZSCSwGo-uTS-C_R# z|1)3tl*KP{#INkKw)8TvK|gY_!mo$No4$S5Sm{nR`m(5|;)cH6EOXg;baG)mR%z?qp?y01*uzLa@VlrOx zb4X(#qAml6`va2A06Xzn;7H*K?~1w)fCrTWPpA4mVCOt2jPA zce;DchOg#k{x<`(FwDwT|G$~;5=9=!LA45(shu$t^}Nrb2Gxs_D*#3D7hzA}y(kz7 zeK--4gR|m5v9$X|=66v+W7KACQ{NXGyDUBFvFVkpdTDGD2FV2JLHQ}o%TW+QGjLmD z@fT(;B=RI3#h&&PmeL54$U~CL+&uw?wj|Qk^h+&6Q_=_cW0vxQ;bNkK6ey(Sn!GO! zXzj$VqjLJAYG~M-v42AI=%pY(`j6W=NNKWLZDV_n!&<7I~^N(J_Et49OA z2CUW+^BP6DlGgLtm>+RW8m;wU%ab`I(?e>B-TO|rFTn0rg58%N^Zhs%5I;>pW4YZe z;Y^WwH6Gn4_5h2r^4cwQkVnz@Ujh4s03O7LB_~P47(sJ{r}SE2kKA2}Bbd`*Nqlw0 z`e?v4gK2=Su9CstD!NZRflbq1kJ>%YhFbIiO#dwy7Kx);li`!T7a?snRAc;?8uhB~ z5mVG5(QUVebBfxZOL#j1MN6wBg#%?VT>cr1Tmm0g0Tggn4Q*tDT_7)&$Mk0nVV%GG z-N3mHEkeH3u@sgbIwD0#XYx2!F|N?U&RW)%1w>H7-c-h@JUtVd3^5;XoRr#lkGN^U zj?$OSI-)$r!cw@X!*$OtZzaHCTNh9EL}Lj;m}0zr@Z}kRmMOLw*qUw^Wh6eW5I*id%m-} z&!i@k&W!z;!?bJxzGS2-^ZUB9LZy zr=1ihuIfs3X-HmGg)M3Iv(c5U*3a%E-DUcI_K@Y5oCaSF>HzM_`Tqr77`Vu^e?S+_ zUWjJrzd;xN>ToG#_h({0dsFPh;2GicHi#*wD)PK`LENB?n{P>^J4n0{^Wu2mOK7v0 z(V{4uI|x!H4zlp7i=;-a3Z5CIaluy%rr)43WD@P7!cdF{1}4=9Xg*uXXegt5c{1w2 zd+!WcOIt9;)d`_+KHQ#aE3$*lM2U{>6L?iWewBW9*{goZ{eL1|)o44sZM>yUmTGSm zCpYQW`Qm-KOU%HFjnTFGq>0&OfuT5@Noy}m!EZJmcje4smk4If0m=^N=1u(?chdx) zjqcfZpDjzt5^ZelvomJ2$2C-UAbOPt?&G1Y_0TD^tZ9_(!||@q)Z0`0Gim!85=jbn zPT>EDuKHim6~BxY=yu0-2q6kI7eE02!BE74Oitb7wD9NF*?n%1QUD8bp&%X91&VDn02f*3z$zEh z)fH;B2}jz?GK6*Sdq|{0Rg_Xs?qlFLsYTvrB-85l@BIPetp^(KPe1l>1~wVq9}Y7< zR0f`$ct-!4uH&R1t!Y~=27iLzdr`(!(n0OoNV2Ak#M*zE?*A@yk#5g)R8%G4(y{mW z6XE;LtavWATE+BQqOdj~I_ISDdYK^D7xei%07x1j$-uE3|Fyj4zorX7$M7)!Yr0L` z|CsLgwN&+b*5x?382>fG+Kqt|q#Zu^lpZem>0C9K_x)6-Z{A@!u#rvbUSCS+||wOy!US5 z4h{t!J%^9Nri9y=tQ%R>HWq_7h5b$1J2mohy&5lk%=ANlA@9jCRDORpR3XrJTc?L! z?41>T_PVm_wsQch9bpwzk6=;GomHg+1 z!=`Q#%B-Qy9fLBw_f;fPp(6dHY(dR^Jwtng3xqDWF(ChNnGKX-3Y69#E;+z~V(|fQ z8O!WScfO8Ok-L>Ktu_z-HC?cVP1l=;J9R8?GzWBup~NtSRhp2~FzaC2%xFN?m*g>u zE!2YAaLA(`!ed!(CxQ=w0P~%K{@m0_j%*I))tvMmTdc zu47DrR>|P||EYS8`hzo%c*+Jah8%SR2@3d$zQCm__+HiY>i0#b3Om+XCPWOO;9=SU=MpBG3bnv?go6&F#VUItEN0*;pN@NG^Y@t#- zaC}sG7P`n(@m}QDgT&{&7#?N;zEoK(;+Z}Yn2u-@>5E)qsnUo{?1T#^uw00i(_%p% z8&$2`-prc;k1Kb&ymCsQyWbJp#fDwfNg_d{p8?m@^4gGyNgH98fCMlb#QEWr4wV5c~w8 z61u#)C6gMqG!hqHa)Pnj6Rw&NlS(GWqYk!%ay|ebK$Rgp>poaGy@%yKUU(p~wq-0b zoBn2w;Nn;1m0QLbA9WY!U@hRJM~iP}>?%9g40_8|1{|N&EhG{LXR$#Uh2e$4wU0N* zm|*n!h0bHP3yQ}+#tGT?@F@xt9D_j+GUrzy{{l<{x@`S>p#a-rZtj zSC3V*4U6D(hv!Yb4Lh=Wy#~MVm48y**R|WwY~=tilJCp*Iz(4hVYD3@p4}Pta`vfM zOqJ!w#&3?_I`CDBEl#NnR8j!Ah6?O^1mIAmHtsh+kU+i)MC$84vaPfmYS5vq?y4}q z1zxP~va&%}ef^AexxTRczp*X^pZececb7YYRVx(+Y%=X6W9jn^9}KH>>$mavkVLhw zH%qY)fmy;!k?;^P9_i%&(DfGq^TdzSOV!+sIJ zIN{CP>at!Qaw9n)zi_xW2e0*a7Z;(j~MdwQA~76^Mg_o&vjf`$nY_QG9W zg|v4Mz|AE&U^(XK4oP@bM8wNoYG#&N{sjR2YkWREKA-9V3xbd~#V`Q!#1%!A4fsoG z*9S_cv(n!qSvilc{4olvqrJfW1n7@YmVhj{D9efoT4WTr28Ij(Qz!BFG|(3-l_^kF zJS#X)XQdT*H7-!sif1XKWtjV;f(-LBFYNHwFF2me0)dY1imBw{OGm9>a{bDcKrR1; zKT}sjR#4mW81afl6=cRNp6%5fq18!>9y*5bP1d6^LKt<=I`uimOC7-qJloGP`581$1w_f22ZnY zl$l-!pNC)cAI1~jHYIlK$olk}BEkoj+j5`Pk@PktkIC3&TK}ze_a(-_irHk)IH(3M z+F83X6c-X}L`KXcN}gbEvp|TGhiLJFWZ)WL-1=uI6Qs^`J3vRFzMSuAY^hCYh> zv;^Bt#E!u~T1)rPI~nMTEJy^gRuEfP|4VYD_Q37t%LWhMS4uJldPao6!DbcQAU;J+ zzXQ@u;QGf0_0*di%5debH{RigwdLDz!SlhNXYb3*j-Q4fDg7R^7>z9tAA@=C1|@If z)KsAUmgO^=j~cu+`Q!e^hZWK1F4pcJA=`nXOx%rCc{u65ik$h<`eqYp%}tw>%|5Z< zY}fl6wZGel&?O3j8tQ+2oruk;%Ln2AHAfP1aKXcm2(WH<>*&m1v%+mFflxDI;rLN1 zGAeS06*9Z;Oi?;MD>isZqhVvD8PhSz>C=lxl&*mI1#@@Ss-+>L5GCRN5n?|AFwd8P(!+e|?xQV1~bNgy_MNq ztRQJgHtH~#xZi(6%Hrpu8#7U15*H+|_urD?C{gS#9EZ?$u54g6{B{^R6xC>!&ZOnx z?QK*c?PazTQUn{P=i^v)I8D88c}}nSaxQqbX5vMi;uG{s9f<61R;C%e2tJzV0p=Wm z25EpJrh}fOm)S&NGFTp;AG&n=(>=Set|H3^sYcC_vxF6^b~|JXvK=+=eh|Le|Kv_)DzM=z5!p?aCTI-qag=4r4u3JGO8ZU81i`MKy%Ux|UfLueR zv9gafOe8qYacuwP6g2c?hIyb9g3(6P>a3KF-jLJV7U+FCe(P~{I{u3=1Ea5#bmxab z_qteC;k0Rc{M-C-!?PXaq1020;N`bbm5+6gj-!?%PqpWX%Z{rA3%-G?no%lKvruYC z6EuGFpjv9mE#f%uocYlTo!emgS@|UERHHPDj=*rplQeX}LxouEv^4||v7cqBC`x8` z3h}2pNI|`&Iq2XOiFoyI9%+};Di@Xyg);%fF1R~1t(#*;!QafTsS?Tdz+h(#k1J5E z#+m(Q#N$f|hXf}yP^VTJtX(uk51b`KHOkwCt{DrAAu}d;s-2OGdl2AI*l8|cDm~>a zCnrqw&8i&Rqg&};IofIDpakF6YQ<-%q^xj98`?{<)}67^B5MfC_@p4qW?&R@=-RmQ zz(R~ofIpP%r+10u6Xwnq3sOL=2@En~X}!>CN5S&R?%;?a3`3u8>weFlK4}Mk$aq#q zL6m1ySDiOFG?@8aZ9waB_uMv3Tr7l!kQA6#QiVa*S(KKab@o^}f%Ggx_)gn6nX`^m z?81?cby%p4EKhS%n>b@QjPJF}N=-d8=`yQv(=(kI_X(qkd zTOL7OpS`pA<{NkFr#`_nd6edWRO z==xEd&bI=S1sEQ&MD-PaL`jg$VUZ=Wnh^$yHmdraa~WP#y>RS){4m^adROPK7dMNl zevWLn>XU!4-r?9rJyQ~E?Z#4?;&xFjENVIs{*(|a|Hu~fVCe1BBKzP4cxdWUv<@4~ zEg^*O-bboiz=u7`(hiU_*zbUIv;R7nPs%E|33S3(oNYRKV_{6{uPs1zqsG~8;B;G_ zsVP=CO5!9!84C%*M+B0>rmyXDX1KMkz1i_Zd`g$!K*~>+09;0c;HAOqhM&<#n%b&hAtqLb z0&`5I&V36Squ~QoI&)O@ym>_pJ<2&-5eZx@D)mu5AhHoY6=k7Y-Jt6%E~pd$^l^V`+~T*n1;DDIp|zm zbVu!vSC%C$lH_WdU%$m-$pbGvC$04X+hsGxZG=bDcS0BV*9qlVzY7|K=ITx9`L9tUJ`XBny^b(%lyuTxEvc;MWVtbZF9dXCD-PiM9Hs%c+GaR0kIRs{p`C|W^*1=1YVOM%pEdSU*OUOlMN;{Rg)l< zEUU4cjOO(hXm~np|dw1a%y<+p`BA4)-cltog<_JX8X?)It}bpZIn*E=jHF zTTuiF$ofseSqJJiBAyW@kwwp>DgYwmHE-}7gtjA(Y{Y>b>dUMCY^g}U_z((?6Hx04b=P?%I}O_86|uy^ zTE708^c8Qbc>=l%2)j@LF)s8*$oBJ z%Zr1eUwp7^4)@bO=G?`Dj`uPm%LVX`0e*6FrFj-ZDgS+h=T6fZ*h0o4Mi4dxyI3bP z1rN)zDYFHt?>WV7r{zydASYSGj+2Yte=crNImN2NbkR>Wrkrc-Af2x-3I_a2i1`D2 zApxA@^tLZ8>C{2{m5=Bb652GvNJ)7cYy{_HwJHeAQ zpJ|UUGhI0fFSAkCNHzmNu*iMspO(6C8rnonNI46-96;DF$z5lY6_Ck%S$zm5 zzvGON^aZRfLwFXP!>;1x1G%k}vSg+@Z02e(Si=U_@IICcXhzfxdqaZM@Mdbo^m+@$ zP+%uv4GHw@_Ab8grw7oG_^0`wDZ@fsi8A<% zACfnKU}sr?FvcUpSO^9*)Z^mGTC<3x^#+cgp%+`)M+IfX{A-he$ zW2X>atLd~S=N{}aJqxMs?pxG=92f06ApZU>Mt37a!(&8uy^VE}8UuUj7g0@x5>M&* zLjJ;%Wlcx9nW$>TcD$Fx=i?W2;h~0ag71@G90aw_AT%tVhtkPLew-2lK?EP() zS=h31syMjXxS#WZ)MYy3^Hy8%tFfiZ^{O)Li*sgkyNRIjU93_TK)kbeb8y;Fis7P4 z&7~iQ^P{=0`!!`(U9ppVEJIw~`0e_@nL7cx(Cot{XErM@4z;tQwg&bZ@u#2`a4N1+ zX^lNq#)vGA=ryR?Wv9LrBbhZc_4<6x>+Iz1 zK{v4>hSAnKu&Nm8om3A}Sv;j$5*}b}ET^Vz%di0l#!1R9al&FtZvtud^9h?9hfo^4(gy^d9K*Xqc3kafij5O+T=C z*X4yGsaoOSLOKRcz-<~~!>jH#E^Rxl{L;PrXB*f9oO<<4DO)6j`A=L-jIeK1kc2a3 zUJLE=UP#*8Tuwm)JJVYrZaZa75aUKybqpK8x2TR%*+T?YJemyGGy!oPmUzkf)aL;+ z0#+rWB8)k~R{WX%XRoR(G$NrYrI7%kMae*4{f@S8(yIP<)0(LpYKq1Vrwfhan$|m- z)Z#?QO@&PI&ItD*$VSS5)S}3mHirOU()1Wt$~Yx2_}GPlLPOnh)&j&>!UVk)==&o7 zyVpmO1?W!NA?2ClY&<)y$80oPrI|GAt;;5$bB(<4V&-rU{1lkeT|@pyT*YAy0Q{XYx1~(^sUq-ev_l zB!1fkIgDP#%jE%#i0Bh6MOXgV6k3j0_-!2p$I;t(n~FN@Z!m;{zW zLR)$~zg~t8Fpz+iksrE3TZs>MzkMwRDxWX29z+*K7jZ277hT&=^BjU+PaMs$Bu-di zVjyhln5#%@zjkcAME3qLpz#LUE*OAGfOEO6VW&$vTGkmtwBOhVocT)+6;dq%qwpgU zEY%1V5B}6N)VCaHD6V>{a#rc^cE&)ct5bS~8xVb`Tqzyd2C-SOj5x~X9T>^c$KiIfN*6AjR(1$MLGLC@ z@5wQe_M3VlN?Q<7`&j~CHA)I8)dj?l(-C=J)mhAX9)IzCLL3uU&tVM1Ss+J}XWnV4A^ z4Cd#L!d-rs$j38>5&os5EQFeah{NC_5>J_imoZe%6rpbg z<{h-Kd?i9>QtQ_MsnExO*>D#UgxY07xFV?tGwK*cYnw81niCmHbvFc#tUS!@uH3x= zabmS^tfSic=EYnDE*lfpYg{xVH#SLR{kxItS{Cvm_*>^M;L@>`i1xHkqZ?&Ektgu^ z7*5-7&aBl#^hwsQ56q&wLF9##iMEADuBoUJJn+*rP-klqk-__n!*dZXiTyd~pl_9~ zIz3uojg$xTCc0+S>*0v)2H&;k|9}?gYxD2rJj`a`1gDL&aWJ<5YB*(feKYXFXl93m zNK#-S`-`Mt9N(ErOCZJmQuYXdI{^lJGH*3A zclY7E%xVU9M$)<~xv;CaDY@_q6TD81w%probNRy>3CAvrNO2+8C@Mys;-gl4*tt4cM2B>Hw~dE`(tAqX&U$|YD=u(X~rhW-}gXd z%}5~~SGp2$E%hK6h-kc(=*MOm;wwbUc#{PAzP@pA%OCv+KE= zmq*jv+m=T!39;Yn;bv{>?%I`w+flr6makSFMby$3gP!lT-E)8@Ji!H0K$Y?P@(5AM zXiu4|98iI+PJZ;^3wB1TCW-bk@`B;cfgDAcA1{}0{UhZuQYn1I>@RAWmdP^zdWL*O z_=IeAdGJs`>0p&-3F@6JZ91iWjiwm8dT?s9ppFU>PeWFIZD4x_a^R*I`H=y%QQ2JT zkEM9LsgRvT^#)+ZEy;vyRC`^bx37E&fvA6;cFWjL8lfUn zph|VG#B_X}IL<8MQFGP(_y)QNJr_h3A)~|%AfL9M7G1?16Ky*sR1`jDA?xt0PTOy9 z=KIkvE`g?Rd6qcd(U^@+?urUejN(VD z0f`FwvT2(%!wmYNLVPW}t-pHa6Ev5?6>H#Cb`qs`X4K0yQwaNaw*+_g?+*|#JLI;P zK0JS1QFfZ*-&ZZdH&qc@6gv?XD~X5~I=N0Uj4+Jsa)~$AcgKf^)K$m7|CVa}4rL~t zg&Yib|8ogPkn24)kCoGcJe`Ej)_H~FhZx&LtBe0Wa@lkCX9}3}%UHjhnyS3EQja%*^wh z$_3v|$KDhc$Q2T(vf-MAnTaYJp&5}Q*e|HwfGhW^9aX&0l33u7ti1DmRgo3sIV+;z z>jAChJ$OxEY0_1eZCT`cCRTH@hH-Q!VuN{tTJjIOtjkgs_EVLBH%&!$Qj(Haffk zw1yomdM}q+uXx~29jKCx95sH2Y@n}mrwEaPttumPrqyaqiV&@ zplDo$NTt`Uk9R+RGHJ_W^Wzhh*|p}MO9?bKp}aDYSgaj6zDx*Z1EV<$uSsTzwFHpj z+Q%LSqR|G999hazS@U>A`D$4f&TvZi6{ev)iE2~iFr4jM>xo#fK=d#@Cn}+zpka^_ zsdDZS1epq*X|HX|(5kun)5hMe3s>#JLAgDA_EA5MMSVfi8h&t=7(tb(;MzHk27dQE zkbK85>0NfRht!E}v>m7^O?VE?r_4&WAT^)ZrJgK^ASg4tn4I;uTx4%*c(W>GB=Y4q z)(EMmjr3sRQ&M+6p`a}twaAJOYcLayOoZ=Yb)lfrSQ)nZ;$iqy^ERBd@5?!Ss~x~qa^D8U)gP!z!;eM@}j#!@8_$Bp>LYyWcp z@~T9%8~GFXvUJeb{?_NQ+3zw?eiYQ#aVG+QYB7P)tcV*tu;v-zQ)sh_Yv_t>`US2# zTtl7#3|_w{rbO2hagl+gFWu<_cU>K-F53>Kkns(5O`hcm~rO~M}4}+}G zn1gVppJGR6AvP%3{$GXNQ*>ne!mr`jwr$&1cWj##+qTt7#~r()j%~YR+qQMmYp;Fw zx4tv>IAh+_W!+W%=JS8&gq&hknb%5+y@H^$nY&`S(Xg~bf)S;jm^2PDMM?qg+VBz&j?u#Wmy&ZWMANH4avPi|urozaQhX)4 zxH+Tp%rgGT&~)98BcnHdjf=8MBs*OMw3dm|8?gP+l{z|}xi40xW)B=PFpU#Cu(co+ zP4gp)U&%Ukv8i|{bLOz}vuMP~qnJ1u6uMYIXbi41n|=?R)?|z^*fbQoU`e}1c%`$y z>EC?33$A{Qeq8xYY$Vt^5w7DZrE*qy%%pQxJlVL<9-Il>`;-p*R`&U_wQCG?P6Bj} zbQg9`g8TZS-a9h%Uv*yF7atnHUh+83cl4F{wK!&y_qr@4qIrI22Y^5}8f zNO3lKjAAFv)EVYOoq7pjxF(;wdwWvpja>eW6YDX|`+%(CO_Pncx8(yn$&mV|u|5%^ zF~Jo$t)OyD7a40Kqftq)lJjYQb%0I_K0cI94c_+FEA-JESLp_^@ou+KW10(UBmCxE zAkYqqzYL(EW{^PVYGI;cBuZ}#QEBUr`E%CSQ&ZQ{yt8DOXUd>=KTr#8OlXBQVE`WS zfrW2FsExAcO0251R;U7KnZ7uMnH02|z4d}{XMX1q`n}v2a}4E9A7mJX4;45($35AX zRj!(iA>o}#@FJ|VHU4w0e0lt*&jGSwCw#RpGV?FJ;rHwOz7JbXheB`uLVcmfmw}lM zu2wED+^vgqB*8R%6SyiU=D!prrd+!&ZBiwd&h#(~?XAXY0W^&n{_}H~g&Ab682&6f zec*&r8HB8D7$2#W{%)4G)N>44?JUiTm1!U&G@1%3^gl)~ERX)~suFZf-dMaza0T3zJ1 z>6>12HGqVO(B>Eo^=qeO_YmHtUHE8v>5*5l0~N^iJ>RY<&#N1#W~T{8yvgOCp;yER zp8GryqpC$LH5;NH_B{uw3%x2kFp2;%AiY4MPjL*WA&yCID7l>=X3WYmU@0g(Al0zy zC))B|0K@!7&|O|j`tZ;*YJbxON3PxE?USBP$?@r8ZKm11hQs9hi1E$v#6~Ra#Pk4% z^+Gf)i0NTLLAEI(EjPG>I-pJgF zEhUjNn)059)2f)$XHlm38|%%c>__;Ytf<2yvNKV6{~rz}i=>8~WOB!@^6({I#}^tc!FnLu!?9z_P1DH}1rJa8U^{LMp*ED(8$ zv!8Y`R+u~j;2D5fEf+ZpQ6RK5y>DxY0~;=PrasRX;|^a%QUAykgy9@B?pdBkUxL8K z*^tt}L=u8z8|X0w0}W^b8eOjO`reC0TXk7n2d#N5&H;UYTB&WIA;v+h4$a|m z5jMR3JbrqkRUIXJFMy(h)qgtC|U zd3>1SnBw|pU%YJ|Zj3vuZWM*da#XyNX9{s;XEF~~?e+H~H{`?gn8;RZpk@#bYPfL& zG0uc^ddFj_MD!fNi7d6P*f#x}sCQOutn{If+f1VrC??hk;=c=U?|Xf|#JiU~kDuWo0UEIja0^bp2~ZoSZtdeaoBB&WGCx1EAMO#hALgO?{mRbU!utC90$ z24V*^6SVHJa?MwINDY0Lyfz)ReV_kJ{V;u#)&AZnB+XL6o&^q8O^iqkBrsRQfS)_8 zwj&4j_>P|;p)+td>1^F05xTsesaSV~*~)l83Z4Cs&Y!ctU@&;v=dQMe7S8su7r|}x zoT*2y5Y|waEpDwS8~Uk-#R@6$qZAa|C6j#iSkpX@7#rVk7t!s|~s(Bc~O* z$XUye}+Xn;LeZN6av(H)RQh&z$mJ)M8);MS~Wb} z61qNJr|#<%H0G2wI@9TmSpLb}l^03^Eg0rc(qWZ=N0%Lx)VHO(&FMkVKt&9kq!J)d zBW2p%>LT9Y6f*i%Lx4-EW}6*u{i*o)7Oz`zd4Rm8eNA5|E93`H0pP7WR6eGFISZ3b zq{DZ3joO!EP5CPjXBaZeSfMe6fKGd6KMOSKHGE=YPAs>XN&ajp2Ha+p!E<_?t~Dqd z-wcQm87bOyAc&0>H_wkn^KiB>@QgX>AZoO7rY_37dQ7n%2cP_?$Ht;#!{mz6(lIQP zX&|+2Rjr1YK$ije?1oDt3r)uvj3O~<3CeykaP`GPRqS)G#Cd!YD|5RMW|!S1;2~5A zL0GjznYFLUIP>9MBfu||ekN&%-xawMB*ep%Zyo^Sr2YC_IhN4#lhqZVP38bdaOp<{Sv zS*ZtVw-~BZ__N-qrMXBTpP&ja9;{MP3iZ(7;ft~jbDy+?&s>ihUzHw#3wMesHcY7Z zeXj64^!*|D#V=j`-MpvKVsBDDZD;0vD@}@-kWy)rDD@!K=w&D96|NU6Vd#K2XyRZZTR8Epepy&1L{w%29l+Fk}%SQ7uR z$p`dSJV|7YC28xRl3p^^coc*w$KVGL;JbWXX=9j)dTm4hzGp&ph*Ngzg! z&vFX9lt97?w-eD+p3v&fcH-apho_1}?(*`c+h`ZdOk|mYw!l@PUYdI}3c)>xI<4QeEr) zcpmh-*r>4+(s8oW9vL@Vx85H&d#4io{B69DK5BS)@(d&(_0ia?CL z)%lzx-XTfu6%$c3;aHE0Wthw1DZt75LjBnGx6&oS6LdFmR37Qq+cJ;Lt3H-3x{^V) zFeG`VeeKbV(cQ43DjELETbpEDAl^;{ZEEUV720-u3Pohb@tW z`G4Tm*gP-SO`f??7UnP2c*PT3-Zck|7`GtXgzpMc5y9u zP5UU!&mrZ!H%DJcu#M&2>nQBg8pogOZ$;mSWIO*%64Ikft!g*?Fxz;2T?Bei$##jY zshk*B2o8X2@Saz;g9dYSh6kcnU%E;81jQFmGG9|20R4wRXP76CFTlDlwq34)`MY2_H zj&3n-zpHQ{=H|IHk8^)~$+vHC@?R1KE4&2-zNgnf^u~c`i7}Nvm6`+a|FWotax0Pk z!zUQ%P=E1>CLTkO>>-KSZ;1kr?^o@oxrU|}2N5zaC62fK&;8Gc2JHswwiL!1^+v01 z8NVAZT%8%Q9)F@zB=Mc#%s33PO%BlsUhX#$sf_}?)@FY*%Vs!q5CN(Fe1rSvD*1Jd zF4}*~qp(kFwbNqy{JtnKiPOm^r}rVG+m|uYRyvk3;;m2PG`qod{%~{=cZIk&a=}kM zq;)!S&BHFJOj+&gXmnt7XmrSqd8L)jc!gXG^?aQqnNzM1O4VeTbhhUlm>S)nxD@Lz zbO}jSJ)@<6bSdg143&F>l|VqSM3{h-3gqZ9Z*g!$70$y%bpD7Vt6O`oK{?qz&^L*m z@0*3e=jrlT|D90s1Mma#0r})B9z>lmmO>K7E6i<5lg*IOZVcpx-7%y1Z>bjB=d&0m^jf9`~IT zmbvNG)MO~sat|Wd2Q>`tu*{e)vXBj;R~u!tr>^j#PVQAj-4}{mgGf;AvL*u}BuoQM z+|5P)qy4s??0Lyo)78F=tyb)gjIEb`lYT^>?U%1dXTklxd#{{{7<)TdTO+T}26hw- z#{l2g{^kDVm7yp%NDtZohkrTB7CgGWs&P?a|97oweu)6@8n+vYUVU}MoVZv<*U^Rv zkgvyLToei-!-w3b!DAWTSQqP>&L)aJ~S_VWv??<kQ}Kn*u41b~J$gV#E?+TkOcxbwK{=_%BMKMV0JHqXqA*1xvS?ybByA8lM zu${i4;J2H;X|EgT#7J&A8}3M1EKv`%%jfXbHaL>H;o;u+V*6UsHzodgsUO9B$^^5` z;)4$C*2PgRDV|W9w>cGwx$rHY8HTEkp$U{BaKtW$qlG{qoz!gNK@r-P6_5#fVrm6m zUJIReKs5IrLffZnGW2BudCEMqn1HAW=wU z{8Lk2q?t}DqHTXcu_{Nl{B+)^AT=m3U<3qjHcml%Y6KcMC;@1Uq><=)wEL^7t@-7l z1cnUNGZwNsd1_@ekJ%d*=IAV1bd4Ep$O(DBAAdonp-y37C66-rnI@!q%A{0Bb~ZI| z3+l;G?o-6yV*+O-6L9{W(FJhg3N~fUo)kFX4&JG8D7f< zBnSUkHCcmzUE^#iV)r?OY&|Z;psl$xgt@-Zo+V&Ch{@z6I8HmtcQc5mo zT@)GdRrRPI25uCFM%i0sb#2lNo=zt$zFgvTOmh@($v~xiT;~loC$;--b{Z!M`04Nn zTinUSLgABB7Wt{o)7{?o;3M9ItTMwlEK=pmD3&BjBq_u@r&LhuHG|GEIGe}W0 zZMul@@e3Qm8HNZIULaB|D>5)7*!BeP{l%4W%CgWXG{vVC@np4n)&s%i6 zm^l_@srfviU0VHD6peHcrGPAxjH&$lk8XTt;q?||9g&q;PCD7EHW^xBCjxyBf4x@& zekZ>yew9|ep87NW(L|wF-=UfwYi+C>6Yrv5hqH%k+Dk0<~b}kTba-euKVf@oPE7wD_v{YAbb;oBR{FqV*l+G>k=VW3&M-`^i zC#F2im6j#T{!pbp9y#Ea=pfOG+I3!%cA<$mN483dUu%`I;x^?PwOD;xw$s z`{hA#t)5^623C5R4Fh^PA3}l$EK4EP;1g5YbJQzOBtORr?j0x+vhvq&-YE#8)+b#^ zm^bV>qeE(nLPBmwOI5KzD2v|iK)j_l{Dk;FjF^V%O+f~Ts331oir#>T@xTXu)j2;yiBc{JS_kx(6*oCdnbVnBaRJqx?Zn1TyGz~)P%lh zoldssF@{rkn5Q~jGavuuDs7*x0xJ3+SGoAxRlcawJk~9lAGp_7AY1V?f>_&pX@eU} zTV6~(nO;wGH$2PQV;7iwHSJ9+tB`&x4jbBz&3b`+=^k&legx#NV*D>oaLV9Mki!!-C zJXvLT<}%Ok&uFJC7G~N&R0z*U@lbFuSMQO5sJK~ll^GvwoE-{^1;JG`u)K%p*EV`iz|P$8=B9z z$Yv+|cxS4=2&3%C4z4+`$_~E$ycz4{ZhugmTsaEAle$mI_7eDTe5v|gC4Fa>Zs@h2 zuHUBH)*fTx?iQIXL(3AX9*kAX+M5(4v7%LbIsM5h^M_fGU?Y{fh$aJUNLS8VhUpgl zbUlzR#5FKH(iJ#t&G^^RROClIf8rFQA8JT9y^|tXs+-oD9JwAMR0U;g*|LI>vko=& z=j-Eq5?I^H|7cUrrq=2{VTG@Sb4WAMaoLqX%SP2iE=AXTZW&oM#RPwQU_Om9`Md#? zm+9+j%@fz_DSzqk&24_tN!Y5-)}S))Ba=ObrhR3S>i2oB28obMLxDPg_AwP~&vCwU z7fl5c`EgH~sFVWKX5@l=w|HEbkgO8vHkBFB$`>q3lTp1m2@0|Lu2b?WnA!$)7p#N3 z5QhB?9Yg;K4$ZkJyJZ~E9p{Qh(UOmWai0di>f3z2p3hrNWN#|;k`}1yDuUcM z>=KDuBrSis6!?qI=g%%>GN@QZoDGp2JqOZI=#Q#MfH~k8!N+1KBG+l%w~diXFE!tF zhn8>~jWHr+RoVO=NSuz?vpm-nk#|yrml4d6a?XNV6Q{r`myG?bg?IMoW8~W;byn6K z6){Dcks&j!27^IC3^S(na-#4Tt9(-p72Z-UMYjVSr#*_yQY}R{;(IyZXuO`k{E1S2 zK4?rj<9|jey|AfHrcmbF5?OouL}nV_Prv2;D@sA@@6#5rz69E}@E}g5pht3n>~rvv zxUCBn^)ANPLB-;_3e3b+xUrO$e{s4CMC1y2dnUk~)E~TwPSZJI{lcuBwPXZ#YB@#p zZTokqr`eniw0VGt=P(ojZy{3Ni#5nBz&a_`Fw0_c! z`DNe{0gV+u3rsfVmsiuao{Y}cr`C+lmlaFm_ioY-#OQT7j$PWd&JcSnzi8OXf~w9t zv*|7Oy;l7(-Ldu21|+C)fADFpOy? z?ugNqrpE>4CmS%{f0_ykC_e&i%t-Wx47D?@qw9fC&C=8|2#?Wv!1+&>0`1^bnB?OY z_SvQQc}-UEhtx_XUh(NiT)tX9pCb#350R9VRv@`lgx^!xN95ivN1j;N^XD*Zp0au4 zDKNz(-a+fi@sGu!&XmmtK%rdHk`LwIpI3m#@Jp5Tsf~hct|aqgXZn64shpBA-9|m0G5xCgz0WV% zqXmDkqw&S5+3`hEYrAsHmra+=r+)ONerr;mtm-pKK~h(^(v(X< zP~UJq_{O)I(!BjJlbb?U<$O)We0CX)UNdevh0w>odKylmMxhRr*HAA3iV&W`(y`WX z-yi8uhFitr&>#>{a625at6X)S<>nZgfHXOkd+uTxZP3n?3JIgm z42v))-EVK!0CoQ(;fppK;AC$;@^8^q%$AC)zG(L_y2|7`dgVPb>{MLbG2pZ$NHoCR z3Ut4+=ms_QkQ~vAC;B2*Rn&O%LjdTx#{waVVoYLsmYWY^S-W8pM36x*9MNWkbmLyBNl%M zLhH|1YE5g;Sb9N>NB`I*-WZg!E2jNRR(>>p%F11*FS+TJrcF*%OH_+nB1RRzmptk| zN+c4cdl-N~ktn>o20vdG3y9b~sECv=p&5xrRR;=q8Vt#6avsWc1PC~ zky?aWz=c3vQ>238gL>$4gd1{FiVQnoH4gAX4O zmT9hH1Pl`qN4*Gv6-mSTw>qX(!`fSumV2B0O#Y04 zM^*w=)$qSBWnjaN2N0tM z(+7j3*7Fr;b=l}}$P&Wcu7?r+?S9;2{l~$$$2;U=bSGv;%j9N9 z%G6hNS33jt_v*vxq@6q0j<}`ApQlsev*NSrOP{;GbBs_<|E`==*vIIeff@%+-JyOz zyo|X4XRO{>1gg_ZyC7WI^Rq}1_2YQnf@uUL{SthJ26t!NOp;TnilRpWWf8ioxtvHJ z@>!%noc&d#eECzP;PU;mNGbj-QgZ%nD-q5At4PWIUquRPP`9&pN<-o>P5fHmley@t zhpocN9pq;~vn-lNeEB!66zu+2S`m{Z(EN*5${d;dWdAR%)PG4a?T7mht;{&+X7A=b zdo9HZoahkeKK830cL5CaL$Dd}UueX5C5V38k-j3$0`I{878!^^@1<=)!=<2WIMrnKrL`cHv)$#3a(Sb@g7UvkC;~-17s(oSN%^}nf^;w zW+_DuJcit@=^+$MghYi@$sCL49mwA9PTn@;cfbasq zOI!lr@|w)EZe%Rr3M1^qv+k|6nCT_pf>;(xfx!vA)appcn= zx{AlAtK>)w+@&!*`=LLRqK%wxQAepI-p01pTBq7#pMBqB=$8ULlqj!cu3iw7OR@TX zb9lcCOOkI(yYgLin6Hc%&|A%NvIK+8HC9gmfT>tY%Y^g|+fW#+Rk3_hx5_xE$NxAX z{Al+Z9RPM1Z?~c5g!i1u;e>x4#s0P!>8tP5=&$4v4xT$&&C zc~xB!Ro!_g9wCDgdfkcO25@vu?n7wcd(!DncjB zG$P_69o+(p-cEzZV52q zC$DHjC9)R>2vF27EtHtNh%si@d4FXoNmKtlOWBCE)jNeP)Mb%LBB9E$&fzOT{4QrI8Nrnqv#t zuBk0728k}ICmcRnCs!^b=Yv-K>oObTw`(#Rexa9-m>>vL3NR3qm!UKP97!tfcy)7;)~miSpKGy?c#bAUmj*%!Xf2W&{@Z^u29o9_6o zCCGom6j(uSQ7vXrG1Xr18ZSIS(UQq}p?t{vpk?&%@7(R>HWif~$+Hbvs-KT@oxI5B z#!wr{VjUDS#Ezt>S2ecij=qnUD&v`LN>fmF#P9~>Ka=ss#vwc=tK zVut712`Zuhz=(9FMWC!2RP5E(Du7#Klyes}k5%7rTX;MwSM1GM#-S`z`hH{HIpK=H zw;>>YYoXgxjh>obf%ef8ub+QL|E!81jy);!`!H2&!#uT@Mm<%MR!5h;UBI=xPxvE zf7nX33Oc=sAiH<4Mj~nZb@XSJ9IZuPA7S=_$G7a9?jbM&*AA+Lgl;<}ar*8Q*Awak zqy%{`eVlSQAw8XPJ_7I#OFE}6FP!!Xjrm5BHoP2D>KBvt?tFbipGp`J&~@o_>DtW% z^=NO&Axv-)3aiElOwl=lC*jNB3_&xADDrJo8UT2KfA5lP$XfK*b^9+q7)7Y>(x(^4K|dBBnqKggHgNR!q2x550V_R5D4E=W3m z@u*bT^8{Z===^~;hJACo1zNUFJ4q6jbPGByZ0Ea=g#yHGg3a!&!lUv( zyD<{fnng_Q61xOsyNPTJaqBZ=Q3qBXv`hn@(+Gj6{Un$(sTX1L-7}B-Nuxby|T=Z8J20R{d7@MOCZw4(WJ<`|W=y!6Q`zco;@nHxutyY&A>U@?|I~xXD z`q99Xk-42U4-0Exagn8fSC%>v(Bm1sctJII59OfF!27k?O<8!eqxCSkTOaegdz4|{ zr&q!h$@#dT$kCgV^7dvG$2P}T#(jqUbu|VLw}i%Ine(}J19BMEb)*0^c4R%NqSc{$ zEU@=ovD5KTyFUg~>+xM1VYJe}KrT{?7;Hqe2iu*Ury5|u4y+^G2fGp7wGqPTC{BSE<5KVQ)Qwfrmvz&?c2}$WDJfBR%V&r5h)L@QQ158}9Z8*jp`FHS-R&D#=Iz z%tB|zYM=vqDye^~sITD7O#r+E@}6SY%x1`szK0O!*>imv88`w7A#=YyHRvx?EEreMARjbu|s9Eh$lO zDx%~L3}+ZWF|!`ON83&;h#TirTga*HSzGv_OuV;|VYWtWw?SVxJKEiduKZr>F}t^a z7uumN_f+mPBmQ}*!_rjgei(IBUo>NE@6Q0-=y2h-a-rI3d(N3_9d<>a0-ExHP&8$! zXT8C+6~41l5Hl>`18H`XnC18CB!_4oWq~Vk1Bui76~}LmsZi{U#O7eba(?h_xWD_N zeMnu+O6XAx)l@`1kdz@mdH`i*a8|6^NT*t;T;p(JT|pafhs@i|>+ygD<-<3yuTkHWWeN9msBM!TMcKQ#+o0Y*jp zcbMLqKnpcOsK&-@dhRqA-c%EEBS1~-1hbH2J%{oOrVz8}2=y$^43OXL?I}Icw=;Re z5}XJxjCvQ`cM?gDL8nJlf>S~CrNf#G3Q@Kjs6N|@rOFzVEam3!0BxO1@$S85f?4r* zdFOI4yK88FSNg@+%qE6oZug(U4VspxPhSIUlt-l292%ESLWu@t>=kjUtY|=3Al7|NA_yd@-HkIR z9B5t|t1mSgn&P=X{LC>CFm$kq(9&hM22xL(_!3%3JUPk+lXderQu{uKc&qt*Q@3Mm zew}pq2{72;HC+-7r+F(F=2?Lc@hX`-P@&*eH77s?{L+4C(h%lPH)^HuuXJC+QbY$BC+tNTD+e7F-^Rtbk+{`o724db zi~9lb_h%CLFO(Wl?HKkpq(FY*#su5XsbZ8c*EyI{pap4v77d8X@aLjohjJE&F|DAm zQmOxD4y-eV^#OL`v;2BJXvt=me1)k#mSNhaIWYOmz7A<3sM^%b(D;$EJs#I8t2?1T zc@BW#(!cX+8EPH!azj2?)Al9OwzRJ>AvGVJ$?D0Bu1zEKi>T~*%} zR2+lW*3GT!MgG>Cyy$;Qy9*x@3j_IiA_^FPVP5Jihm&m75nm7ko0fh&*mzs*xDwsL zo%rChWP$meAgYEz6OY!%(G)pAgVkN6T-=*NU_dc3tjFpE-dy3UkdRi%#g|&ER?J+ z3CM+xN-l$YXw1))PQ`@*I&sH&AH}~3bCJvt<@MNzTp`XGTrNml>O@EJ%?lxZo9@*@ zG#p=X*=8rbmI^LW;Nl%ayf7MkDY9Sd-$MUQ_v>OapiGs2@j-Ny3!Y@~1U@3}OY(i= RhTjWl+gj4YhZ+;m{{h1XZjJx| literal 0 HcmV?d00001 diff --git a/testcases/transactions.json.gz b/testcases/transactions.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..7f6d75b7b8c5a76e37bbb96541c5f322a5654de5 GIT binary patch literal 383526 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

    O(81TrcrDcwdz$XjuLK@_&tuQjQV%#nV1p3u) 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%0D6~9x;;|IN zbE#h3G+_k|M>h|QXmleJ+XQxRVS@&eU+`9eywYTq`_a(vw?+$mvlV$#Q3SFukYRXj z>=@gSRKYOi0hEc+;`$q6{fIx~sEJ*^HI<~&i(%$vL~m9t2*JsRo%})7@jmvct8dsf zBC(6lRqwF4&w$nHS-LsmE&(=d;i8=RdKwP?&iaagtrD zK(Jl@U4OXV-2+}bh$63@J6}^$&@;n*+sYx?sobT2mLF(W;iwJU`;S(D za@h!)5{osgGZiiEVxg?p$5gW${N`fZcFFSbqDb`zIPqir zZd(xE+|;$T)aU;6UiGbYWBU{m|Lo%79?`I1Ad>_wC3zJ8L5U7<%TbxfT!dbIMllG!3-Id=+W0z`}D-j~S znSR&Z%!}elGLHFW=GzO~aru+YPWnwyX(7-qC+hMvGRq`(4i2_ZdEaM0t^g z-uS*B`D%-w5@2WgHV$nR-T#Z5mAc&M!oj&puo^0i)hcN7-tip5ZJPXGIy}BeF}-oc zB1HDtDuU_?W7RsP?#?M;0ngC@pO-g?q6Wyw7p#)HzrvXaa5(@laOOwOBx+`R|LpwL zX~!lZ+=kAp0PW#&%VR_D1HDu~yHNhlP%)dKGHHq+`0KSn$!$SYEw5X_p=>llD+rJGZrC-`n|h+TUq1kUH>D zw0F~l^(fBEln}k*;vI!M`{V)F5K4E^qML1(Hew@FtB$Ls*=rS{M>o2?L;Ku}p@!V) zUOrN02xZTB_KBC`aaC4xSW0m(T5ujuq#vS4O9j0np86bChKMId| z>(EbI{amhLs3$(!#-~+xlWD=MnNnv|LLo6ZLTDXbpqKMugWdC6w_mTta zuE|j+I29hVqjNbL2~Z6))k2nU<`dGOK+JHCo1mr&rm36MTgt0K|4RZA2;DynM1)8v zTwRK&Rl(~R0Cq3>YhGFi|Jm{mA{LYa)ji$a*Ya|56@7Qf{_#I#Z|*;`=imQL_98lR zYkzm?nf9x>pGm3du#Ke{8Z_ikYZHY&R^54f6yGuv!<7FQwsFY|HR zfe}fNmhcM%B(+00$~yL&C+{e{l?q^6s)MX8ET>0?4g19mF zs9yde2IoUM24~qI{8baO&H7Xx7oe^G@Kf~6LSb9Ye+;#fl?a`rvTv=EHJA-Vo;f7G zb#$VYwXJ72)uP62KI%Q}QI3&v%FNK-ZcJz3baL4zR=MzH9Rb5vt=}HClV0pu(*s8I zoMg}yM)-D&&_>Gl$>@DK!G{qyy@@VYSe(S8SlGC-LxbE`7(u#rsA9gJPHtAM4rNFRRO_zBAVFBxyyAwmrT1!qCZ{A1yh)aw zqnW@pWAkg8VQdV0xlT~j7X5Y^PdJDxL>~uzK8&vy-%L5c$4Bm~aG!wbhjy|S;4ncw zW(apR?Hh7TSfzFBGq4;bGstcqH%yX76!fn(@TVwKN!Qitt&ZBkBy(FQhLF?!cC$aOm7uD+jZLD$QMzH^_gk+t(Hs|F7NOPQ*Xm@I?uS=|RwKUz-| zHxLLffkF?%D}rx>Si|yAUGyl{3r`AdQ_CK(EIt#W%hwykpe4>U1&lKL@j#ob9R2+_J$; z8liE}Ojj=_7*|-9B#(gZKF(ber&f9y%GHv^pt2HJJWU2rVCpN^z7rWxBQlTkf3R*V zFw(H{|4wzBBpG)u2o+Jnd@)*-f*PP|b^;bOq9RW+;oF{_)q;M`%6OsIrPe^)OkDxl zDQJFT6380K(Qc^Vp#SFN_7XF3AXZ9gCJ(svlk0o*SW}}^5$LixpT=% z4fhBq__gE7Glh-TuKB|cQTEsKeI6rSeAXfIf4U#c;zL947n@rY^h6BAbaV0sgpN-| zu;^-?dacz}^n7uoS8ziRvjF45i-^?3L1p{4Z6JE{eIO@onJwcf{2eVlFuBRX99{f7z9g~jdg&& z8lA~Zlk5J#d~C(({tDo>1;WP={{ug`hw^tnpJQg5iBDF?X}WZ8hV!ZSq<-3kxw(l+ zFXj_oyywoXdoLC|uLUtVdGub&JZn1=>>Hw4H#p#*9p-0r{nx6mF^B&Q=$o&(dr@bj zXc9&*3iuEGiSB#-5BvamEeAcwhgO|L^Jn5xHW4sTLVIAJp4`Y|0hJ0IZWLn;II$Ax z$jx)KxBE<}5Z0lQL}&SkA9s9$S~99{5nAm`WXp}t{DO5eVzQa74;`R|ORo6OFU74Rli#d_<~NJYjQghoz*J>*~VmK+r9( zWscy|Z&s&)s2(+eFU}2~B0bbexV|ksWzwXS(_HT46W-FZx(}MZdJ8hL@c7wY?eH(s z34y%-bp5>%emnWA>xHFa^%&Y;R7>hNIDdU0pW#*FUJzXPMlrxN)YhBo<3zjFHP%zr z^SJ*Z$;N7xYZ@vDAG10V8A~;QE@dK@&2{LjSgr&dDml!CCd^7>e*(<5{?<88JR1yl z^K94=H&hz6MZO2G>m|#*6}g)^JtldzKn2KPe9IR(EyHO~)0wd(%(r@8LhT2QyJ66(=(7XEyA&JtZdpSXpUR&}Gf~b=B9rcrl z&gBiZOz;+v?1UWg*RDMD4PbAu!WNd!WTo1JZV@1IAj7p|1tSi%O&po5bRh>=k0E$d zz;zCxsQ73ifg3iLCQ(GZ;p{=8=?uSIj72_9v&e=$?g8B>+GlaF4 zhRLT*luy@W+i!vYHHc)5ECMa!s~cW5@XhfI;@!}Lu8*9%72hY8onQjS%Xue3x~Tt1 zQ2gOUHU8k^;7^PaBpg)^l7w2@8(KGmK?GO`xo9&0obR^;;iIn1 zya^+!j3BD{f>(rNu8>+zTOnN>v1K6O$~Kojcz8^3gdcQ-Aa{3o-`*PJKKR{>O#NRr z7S#0~uUJdAcqKWrlDjL`s!jLzCjOv#cY(z4XY58D`f4NDr;+g@lKgE(+c>*lm_(XL z>qfUMUwJ>JTcQy9rEsi5L?EI#G7s#1RsNY>RVB`x@LaZTyNA~#f-+POw<5NEvlrC3 zD}!gOW!GDO4HEcvZP%^dvWO=~b+j8%cr9s0AEWBSe?ZuH_N)3a<2?gZqNrmJ5|u`E zBj}#iu4oweZKg|im!|=25gR!r#=;|Ox)0&HB5~j4RZCOH!;7S+QmD8_uGp>oyX{Av zVj`Es%gp)-$ST+JuOQ|&X+YO|D{7lur>N&%JzG=+*I>z$R-53}&$Z6CX zUQWzKzR;lim6cYZ1nlT^@=6=1+_(j$efAE6#@|EFZNg<>I5mETD|_YkYVj+lHz=C> z-1q8+V4>^d>N^VBlJr6`wF%8m8E)o!LW8ON=I)yLUjoR%jtoHj*hGqN649b!Bf%cT zFW^O0ttfL;J~m4A1#}!?Xn-#uQhzu!S}OzN0#XDqLdDD$Qn4fn<$*uea|7hX%owMj z42J5@7Pgpirpxk0v#HS-13tC%rpFiCr0Naaj8z(zduX+afcEqUF5qOtx)(pnqal&) zRP|HUGvn{vzzi%?5;jWSa~A#|67&I!-mA#z=DIx6M%-tpY$sj3wFxi4$*Tn>+h`^f z=5`%2nm5(Eews*cTw0cLQxl~+01KNHUS5x1vmeW-4hohL9}iYEp8HnP)WV8HJUhE1 zX5}=n-8Z$#YqBn35lv87KALETS3;w>oUe7;`f`M@a_1ZV^S!pASG)T6F<(;N9h6`M4Mbitra{CAY_XVO{ zEg_gKDnXMnZYvE?6TGnqQ{r%fxY9XVoGVd$N$A#~@BHPXiWak>WIQ7k*rdIa3U(c` zX&j`IT%`{aA8&z<;Xy{$(#ZA1wVl1!8*piZ%mBc+g8vT&fe-!%1_cdT82)5J(mlY9 z50rru_&`yp)GkVvLGN9(TlsKVut`X zhyAs<-*4Ghk;3J=a`2tMwwK%oFttM*pdosOx?sk}8Z|r_Sh4;}my3BazFgGlnM=^l zg>Fk7mux+HLC^)A7!9hSUie2qH4*E2RWMxbpO~6%* z_YpVSG}x}Tn_@wOsyI5#Ad9-y%jkR zX&aFR8A~2#5g%Hu1lG#1`L40~@)(%91>qaP-M|Y~atO6G2D?DDwv5CvF3=+J#F z4%66kKdsZ*0cic0eaZAMP^YT2pA{n@{s0=eOZ&~vTlU~9xb&a~FAG_RJ~rCI1*FRqBQNrx+jDb-XTZQRyLhqSej zY_Vsz#%iLVn45Z^zL$aiR!Y(_~90~=;0Rs z((}mx`7tf|6YcsFqt%_T(n%cXrh`v)@k)+i4}0S)zS(Nho{LhJ>Whs*4`cM<+6qQ= zZT)j$2ZdS}@a>xo>^9<>uh}!dQ>5(|QMqEXX1eO!Xmb zpKSmMGdOl&lssQtYyr;xhx>zfNi@=6dJ> z0qxP^u2EPX18F#+R&KI=o2nLM^M_Zo0(R<0&}pi(Ct2VTVQ zW1Dc|z)FLcOoKJR+X}2EZ!@zVgu`HpE?ZUg&3^~JD4|JROhqmD+jUIa@$T|(0ettl zdu`BsGm~K3cOs;JVAb+j>-+#tz{2Y8Du+fT@&6)12mcYF>g{i8bYct@{f}%=o-U9u zwnC&&c5=zvLpJvGzsol%xWCsV5M3uMLBLAK9mvyu4a4drUrGy;W@G1}L?_#smU$~m zZfJwDLFNmV%3Hr>5mPie3xLMV{{bPVkMBT;B@5Xe3J*Z1b2_Oo$}y%T2`ulhFI5td}D)@t0N7 z_}G-u{-dJTGS>cV_xs%!t#Bfx%u7o0z-+&qNxSA|f?j z7>|gNGmOGNVtpVanxLe7^8kPF7@=n}pYV?F(XF@03xZDi4$w9JwX+@3;a~ikfyV8q z(Gs}I4jM`y_vYpH7-o5KRXEXEJO{Ts$~raWdVWuEJXvSS&saC}!0`zNa%?@wyI-~$ z)=_ok%nIs%lmOCq)4}LEz;vU^sH7L{*((iDw(pV-%CC*0urn}u^35J?kK+M>U_cT! z{QNX*!+Y}xWJD8HlJ`9VR5nBY9s$z)VMK*ij4-D4{}TZ!cUJ)q3%o~wq_#+Wr)VrL z@6mz!vYc3>k;y<=!&Ri{FdcvdP!{HIDkV>TMjO|jnw7lUY=pK6eU^bz7W#@n^I6rW zDSWNVKMh5miNk_f)h!5{4`h%t8gOm&#|@^87OJi`4R1b+zvLk;&QEq|GuOTK04zra z!N|P#TeD)jZH0@axg^u>7qxy`_h{?DR_1OB&t3oo2xlDBh*52gf0@t{QN_pE+|6d4 zS|{G!QK&7Jjh)driELLWvEs=u+5ye>u$(R81OJzXgt~o7QZ}xeIc<(s9v-#Ez$O8H zir-i8od&h*CbTzbm+7X(TU*d6ICcXuUGs9Ajt*TiIZyYGD59!C%Yuz47an(wzbut@A@6PylaU zuzS*hk>tM!5S~gqT+w?3=V8RGdBRj*BckOr(E22)gV)9)#)p|HXqs1<|0H zR*Eu*VokTI#z%d`zE?(&Lq_fGp(bf5NnrZz3-IGL01QAL%()v+U`ip^|9jli<* z^d=R@|ILF~FxV3OdB{ut@gVIB!X|fIIR?N*VFt3KI-k71&!n#@)G{HlQFsa}3*CST z^r0Su#s^-_9!5Y2iS+BPjlns6D1qs?)mIU@ZhI(7_H;CV5@h1NM9>V9#!~Hfytn6BJQZm2ncAEoRIjFUlE2yO*8W`DX$2OOi)(7O| zw+y|8y)J$)Z}!wKJod!O1+%LaMRzuW+=DW!J%bNa*Y)HA?m;pKiJX12RyiMd4?r4` zw1OUusH|TBIX`Jlx=qZ}I=}^RHIQYGaL7q~ zyjv9eu!Da33h4L$p+N#**S|0OYr@fKB@CUOK`rheJ)u_V>YraG7i%`E{~U;G6r>~g zkc~bNQCF}O=ALn^a^#h=6#LmMod@MkhLv5<4|#+g^G*C;KnTx=p&hUi&~7Oe?lrpv z6jd?=+l&QCz}zBJVb zP1_0`I?ev@WKhfkC}Ual#OW@)_V=p8KB%K~nu3beuqnU1E%b1~hTMI&{^b|@S2hj> z+IkNsC|&8Ti1EkQw2)3SjAQCF(qH;Qbi2<=+)F}~UXwK^qxd==C@ve*3bYTnebvq< z52>F&ncD~$-keg}3ZS+tYBAVLP;aGOk!&U)7eGaRl{LJUA>gEhB_kCsRiMPkxqA-- znYYf9vu|R<3Rz*jgb4O*{ZemvzWVfE7zm;0Ul<5pFRb+k(>4iT5_jo~#xPXAV2(LMSvw!qg>3?~kdCVfc+KBc3 znmKjcK>}9o3T63cv+{SXkkbSCs|oFWPHF3efnbldpszaVT8UcjA_w=`!->T4-|(i8 zyT1!>2Y>(2>@~)TS<%FNb^MuNJXy;&( zUviitaP=b`tg&wZbwyEYEw@d44q4C6c}=q7Y{+Xyi9XUTM&1K?(6N};O9kCD5i2Ut zCv%F?cBOuk`?E|TH68MukhFaHIDk!jh2a4rC9J6Bf3~;uXD%5dt&3Z<%Q1{iL^L>JYZg<4kaYckCxq4B&v zW{pj7H^FiLY%lqM&ztp^7bLyW6E%i|PD7MP&HaF1tOV8M`boL@tYW3$pI;t=z9H=6 ztxPdW(ybHYXTg@IH1KXGRI#b`fegM{j?8qRTc;ijdN7zAaUF1p*NbHUuF1%nJ7(La zyw)b7%EsnYqd8^|5IVO@@^o}``QFVd&5e%l@S=?Szf+FOeOWd56762RIpt~S^;Z*C zH1BTM{>I=@EYG@&#yv}&>+TUt3pekjb{E~5GarXHY#Zi+(kZ7RLKGPgmP17(ETq;< zL%FF@W*B-9;OcH+^08iEn;8ED1$j}_`nh-10OaHnIL@G=fwv(IqJ;knb;!y_AacAu zyyOgSLrQRxOG{44uFL$LTMoIi=qqa_j5bW^z@hecQ$|t+KClB2OPPsKB$NX6j~kKc5~#7gxZkI$jsLKTKJ=#xs>oqxXy~7?OlE z!AYk=+Q`3kN5hYi?ZWqgG6->dDDQ zG8uX)yP$2sO_g_tLZX#``0F`~lwGhg@5#@x;7bWIC7+e(2Xfnc|G8%rXy#XQYy}$o zqs7BDwWwGX6Ux*3V;T;8T4v7U*-FKL!aDdBT){M8KYu&33H^M8p(U%=dJj-0EwIKB z&u-O}o$QAB2Z>m*fH(;|bq%@xcS~IdjNQ623~yE=&u%qDQazpr=?D}(t)b#F1lSL) ztmRQ;HEQE?M3)=Nw&Sxxv%#La;1Bt@8mH#*4DyDrZFJY5lz*Wa2W=yX)X#PVt6!eKu=8$@cg& z^lMG8Cm%QK0kPu`4cKv~jRm9quH3d|r3{)#KEFH`4{L67{FU+-CRUok-$w-j)p@bd zjIsd%fNt$tZrHJtpK?Ot7eUeH66(_R031CVR*YTg>Ds$JxT}PYBqyhVTYsqYRm$U) zweL|)lv_arEQQ;+q6AH#Lt^KK&CER3I?Y<1?-7<7^1$TReIQ-DFJgHEFmw~aG_+>A zV-+o@#ZDTf?k8|)OOhFndahfKzOO;#54rVv1=4IGuIx#Y_{h<{CZD{?(I$7z%=ZkQ zfiHI7r_4{M8}vQHk}n7Kou~mm#6)#ewvN!YX?S6ze(8BYv+pavAc{4TiM596*wxOk z7}%Hj5rz1vG$@S1jnI`TnB2If6z!qylW^gB%hQ7U)I&Wkm_g+&sdNWd$oE@DZ#hRqMDFHDJ5b{?EN*n z&`F{kc4q8(^&I%(1=+YADgY?V9wJ*dK>SQgC%tzDwq% zxQM(APNPTg>*hrS(JG^)vnf(tNGVEknkWz&|%=*1u6)gdG4A3An&nC3Vr-`CAF2}mT{fNmJdaV_?BBb2U0 z;d6jQp#CK+v{HO%RT6C@a<4!hPIc7r>#`K|RAIr)%+YF%)5U%8xIP0WgCadr5i**L zB(H+KCGgu~-H>eP#B{D~x!e@|6a`-SH#iSBa#dtiU^GHsHm|>VEbg0e?@!dr>hDm8 zeoo$k-#S~Vrx$cbi|OY=^_ut-}IVk#ZxEJOqFJZ`)B$Kbo| zJLI{S5Zr3Gxql9(l0#w^-FL`=-TLk>)I}fnSfc2nUb|F&)O=%5cfp`Y$nI0EHVwSC zYCcRHs~J4V^0e4N8ULzSl)8V2{cdPU<1Pl(HzK$H8khvkZeMutxg^8T8aWV!z1p?- zgE$*QZOoRCS0v~b&O>LA2o`~i=|His4C_iX9%Y=}oYuWuV4s= z{nz_*XA#5U@0z9bo^uD$r-2{AM-GiV9glztHbw#C6nIC& zn;Ym1H9Q74XU1kP__d82-&}pJSu=D?g5R4TaA1X6P_D@}oQC&5Ajn?O>}i?LV}6pO zXM4oIWz!r`_+b<(HFuasnwg_Sx*7j(S>+ObUsf-r-}fnZ9Ga3120vfhL5!{ph8ZUt z%8f|Aqz#l?!l|L>1O&lMv3U+t2m6HIT8#zW&eNt!xaQi)!tx~2&L?QbN*?PN5ri}#e4m+&7;>^ZFQ z&e64c4u&}mCshm%j@2c#GrWGvZ?x$qxoieuJCO-`jEvA1EbR6=U8`^wF0ve1{wMPtRRzs%0vy!ke$-tLZ0$fJuXKQSCz_*LML}v;@td!FnR!b<2`#cLkZViaW>Xbf8o!Iq(Aq6vU$kvvNWh zkH^H^O@|eaqL0iS4sL#_jK}pdSyIv>Xz@D4#qE{T10K0Mv&S+`oi1tcvKJ2ujcWy- z>24_^uRoOk>4e>De#g69t|xy4ECD;IIEMPAQ@AWfO^SU|ae`mq26qz6bDBf=PV9c> zkG5Oc%aVQ2quO(S2jkVmu9#gJZk9*s(uaia0;LStEY5rAusjH?Z-~ZlNIl&SJ^q_% z?Ho`CTfW4?e(Q!)-n=QoRQ7%qbUN&%)UK0dXCIwWp!~Z{i6=JV93iO%rU>j>*R*4T z*0t;8%1vh$*eM)wN5OEv^sF@cgaBbox;N(Yi+Mw526OCi)YODzg3YY=gVW)wl(rT# zIo~5sB0kT_GDv)lSepm2)=Esn{t;=}YU-?pZ(~U~K0jCr+e3}F1FM8qoi5=c-T^z0 zN`C6tA8=q@{GlT1#I|~gW0udh)V}ssxjvdF&|{OT&E!ILZBaZc1BK74QaljJ`guXb z_0E(Ih7!H8%WL~^J2Jfcs4;f!Z8Sev5)(9K`Aq!8N}4v zWdvO_F3Z6bS%wXN{Xvs=LR;3=2AxusTH^{2+0D1Vxm{T22VHmjZN_pvg7pViJ%=Wd z((ZtyJ?Z21wFy0!1&lc)9~X|zf=wX7ClrM4_5uE~18pU!gb%P!{37KT%**}M zTetS7A+D&g@$&Dt?Ms)UI(x#tx(v;%C2Z_t>ar!mepogUiO~07IJc-UtJYc$PZ}P4 zlO##tV0DP+CQKAC{@iVeT23<;1B_Y05H^SuT=bp3Aj@z{H)a`_gCvW3_@Pv;Z#pNk zwl7D@k0hgjZNJaXOvsx*yLku&m)Th#lF~|d zIHyO6>)?-J%`1bRKM)dlVOd^Mn%Aomaviq{j)Y?hfq7BqKd*s@26JuxPTp6yLp;c; z-X>DT3$e`)LZ{CjjHe7{a`!j;+drJ1{`j16{N(&Fa17lL5c+EvMZ(s-wDF6!%tvcU zE1XCzib*#Nmft`%GZEq(X|AvZ!c+$55gfW-pb(v`GZi!4a>_})x)0#m0(>aXD(;&T z;@V(~3GHblbooRk|8QvY8%;8XKKAmxRU;G&xz%z?w0P=1i)au;ZgZ6{lsg-woPL8Dwf@#>nI{1C8M4#xzUPk6z1P~V&5bNs5l>mZzpGEt?@AXpJTRAv^KJD6eH^p+ zX&x41HE(bBnIu`5mHw2ZQcLZ@*dd${IE)SS0*Yx{ROki6Z0n~C)S2a{`Lbw)H9>Lq zmopA)qor=yb#pZLo7Z)?OY+<~W?Z8vve4cbxMYvS1xb^7Yol8qFOV;a35ucP{7`2C zY{vBYyemGZ@qDv$&F78y&iuMPQ10$QJZ;Eo4fqQMTM;yEe-eZg=hk{+c$9`f{%deY z$)A~VaRpJcQIm0f2OUc$`{s0mv-qaOPq(8%NL)i003=c!XK?TcO7rf@m_XAL0sJ+3 zTkuhS<#`?Q$@Yo3s@|{39+vPimX&;}BRQUobhH)9Z%gO!4%&}sXm1a~4MuER6(Pea zQ!0=BVvZk;8c#Vnm!|*q{bZ#pXn>&{k4t`rQe-^{jSHn5NCR!jyNlc~q0cYg#+KkU zp<#NRBwrT*5(nmIE`%I^oH+ks+hp+{6 z(WT;V2ppX(Qn$TWu4l)Y$-(q5>T&U-gk(U6#R6B1Mr5TDl}dWQZ024ah#R-H?a0QC z1s|UOONr<{yc;U3kIx_DXx`2`&eX1IvvYw3FWL{cLe$M#qTWT{W1Lppb<37UEW?x4 zCVp{Rp|n)0Dx-{tdj$v5G#$_N_bN_R5E#~TS6W`Cm3SHiN<{WBt^R=j%+}z+$iQ~r z%I-YEV6Mbcf})vUgZ0&%;8b!zsDz_ugt`~Fm;(q5R&tqPlShU_i zprG-_uX|T&C)b!&VoJSfQHQK@DWRRjpUL{Z(nvK9sRfZyZr@M7msNnkY*LDL>?DXB ztr0X*+Uo3kTPz6dF2bHrZt{3V7(HCGtfR=7NJQDs>Ks*RvVkrtIU^dhz@7&~sM}5M z=VlLS-HcQ5+qid=TGzxj)}4nc%W$&xJx8%;XBh4q;~Di{som@kfu}h_g+?v4yY2V| z+VjZ*4QVD$mP)96?jGeLroS*!(XCX~CEI08g^#k`tX2S9-^Ql)V=@Js^6?jW47?#K zx{NKcO;P$(ZbENutn$d}_yH{k6bqHf{A?lCwCaH{7E|14_N@LZjzxf7E; zFZ5Ao25l-r*s9B~^sZeaf1XvV>KcX*R>e#S$naTb5R5o3n^snPAZ^H5* ze>U+{rN*){6!nFZyIzZ-wFJznhfna;mb3Bde3!`1ZC23Y*z_(W^NJY@BKk@u*d zeNS;Ks7E`Z-*M16k(L#zfe}W>iWMB=aiM`>t}Txc&xzOZC5P$bevn?jfWFt@VN0V@ zx{PBw!;&mTqp8(XZdgF&o|Hz7FZsKikJX`VIPokfIT>wBoU{F(Tu>_by{uK^YWJ)b zIe-Fp2VaCfx!PB(5j(mL3Ct5KuZz_Y^=LaB0;y5hD}Ch5zcP@6goD)9DRv7#-l91YMM8iYJ~Ghb~I~M4&*WaZ3UU6y3AQw z7rPKjO%|s_ou;{YpO9`Z?~Fp#i`_OPUP$eFvmAUfIWKdgPO$%@>`5ctQb^r$|3~$c zf4b0TkMZivw5Pmc_w@TTy@4JMP;r-Q)PhGMs6BnslEo~0EgRk%1l3n1SgYXZp z4NPO5VdZZXk^Ip#f#*0`*`0w0J5*ukrdi4M!k;-NS+Z!KzZ2bk6WnS#dU*0~DQvqr za6Nf>ioB6`MV<0-OCZV76WF*-`gEMBy4MxP@psHdZ1T&uH5Bo#&wW!;a$0MZ;yy%C zZXxrzdi*wbD19}k=cHY#uG0@=PHSG0T}Ii{7a6au{84Xs4-`&BuiH!2t`hd7t1~{K zMFnP5W9Rn;dZmI#`P9?rl7-2*+o;nex8XF?on~l{J;X;%rzX$qZcT0FN3Q3V&ufnM zu0Av2_~4MYB0T}zhiFYDA5@|rb}P-$QGb2jb~gUr_~_^myzWw1-RdT%i1wpRC^i{0~NC?x8wuve<1&4y+&s2)sVicRJnQLhHNfE=IGYEMG`- z*^d7ic>lbwZ%x_Oojp7qI!3eAd%sD_{ExvC73W{e+TxEWzU zwS^V0g79$fe&4(r&gO^kyu?6!M~&ObU-kz6P2r^SuPC!Sea||*hB$aG1#Zklom=r9 zC``NGRcq(uuR1pAzsfPGADqn3nf0qOMQWS*x7^3KMT(v$Q7N{i3Y2by*KqW#0~%1@ zMHdc)9Kre?;GoJ|b~x)?hYD~Mu2E=BB`XQVY@~3oox!PZzDuOQ3#TA3-X=b4|W~kgW$uhe=$$S4=n*2RT_rk zfY})PKBUdn;7C^%VZQMjTn*5bQC9z_sX4-JHNqD?0O}P*I$3y);!-y%hYQ9ha&47V zwhf%GYvX!8DZ^6cZ~xvxd*$C-*d32nor$M)c{4>n*60{!ho_wVsBP0a^;$DLtE@l1 zCSTbU>ac9s&%hG^=D}?EmIiXt(|%*7B8)hIJ{Yalh|AGrLt@3sy`l)Sfi*ia3DWWp zQb`@QjIKeiK{Bj?OT)}45!H~oPl5uuf$4--H>sg(+6Hw`-^86F|IG^c&G*oj&cfn? zq)}JA?O&%e6FtQ9Gw!KlmLhUcG;XR+qX9tg+XxRX1CIes^N!ue@5g`YemTT4;I7qO=j| zGJ8Gys*NQOWDWd;H4nS{@Xez#XfqLh=&;W)8bQBC%7p5gnplNdg3G#~rsC7IWvFa)|JI3)I{I_ZpAwzgc#z)0Lf7($SMT3XZ*JP<9Wsmn^IK2Kh49_DU*U^xK z)UUR!TAmaZrtTA*me&^VXSf@^#;{h_Ht*pGy#rvI^aKX(C2$`MP=0hJnRz~bZN5lP zY~$bdPL68c;8%8a9qfpB-@$ggujJNnW4j4&po1)$0(z}VIo!=Jxu-zeW^wIsw`>K6Q%W%MU;nS8? zE<|Ci{-IxGXRZA~mh-}E_jYHk|KYkI*nIoXz)bW8>ufvmNw$LbGNrI_(?;|!^>rPe zE~ABw%z^f{zi+(fQipGU2I^8S!c=TSF5w>D5N-S>zk05p`E@C^ZAvKwt=sssd_DZQ z4C`}ceE5LuWQ+PT6yIg!vlTs(z3vs%WuLv3soe1g&J39$u^(0;UJyq53$gP(Pn`fODY$1{#qIOn0&w>4dRkjR-I1eKZ9> z>Q7_g8NI$}rfI<6_P_XzF>?aNOQ(6>1q~wr?t|0H3>p>6aq5=O>v=N}lVbH!_3|zA)I^75HJo0|o*qg@6Q@ty{tX$1LwxpbBh^E|Zq{-Oqn2Tp?5V@0 zsVJv64w@siC4`15bbh|O(>E2Wh|%t?Fw#l7J9~6A7x0nFcc_3*d>F?Hu{q5gyeohK zbx~0Y5y)is2wjs4r-$I|w_0BCnvg{^%kB`v*)HCH0K3DznB!+leFy4ZIkbLM1I=3M zvXZC}K zc+?^Gs8fRj<*KinE2*v9zcOspMejJ|a11?}fSJi> z$z7$ZlVu<#M26$;RQ^i;9zk9cyyO2+wpv~HN#gZ~kFN(*X6p^ixv4>Rd|;%oJ8j2X z;@my^!_S5%h3JmLH=K$egPl|_rl$%!NvCW{DQp5Pz>p>2*|>oPXH{$+&mnE78JiFA zT-0~5oYZ9$;Zxpi9Gplx?&(;wzMJuKT!l>RHGM@)u?BohhjBMitD3{2nno9 zsx;Fw4B-{7&FB$5k3`fe z2c}hyf>^+L2fdM|uGXTXh@>VHuoS8}aSXp`HvV%v{LU1N0rQS-doYG`ChRgd$on*q zniG7NTbh~rq8QA{e0)?A9@z0y3}D~Op3FHqIXp30Gm&q47-pMk5GMq2CRvMHQ2J!x zu^v0}@6K5)_Wjt)@O86ujL(PvZ{5@G!ESu!U(1@#jW1bfOMgysW|9uA@;zLr+L$`D zC_EdT&o7>|V6+i*IoM0pkb1@z@G3vEz~=1>0_`sf2~<6!?26(HtYu4cqha*XejW@c z)>BpBDcw+r&5x1CaFwcE`oF4LjT35G+@c$K>o!=knRMjqX7<}i>28{4w7Y1X_G7Yg zEf6921E2_kQaLWIdXf9>NRPdCTVL=Rp0}z)_pUJ{L}fO2$s7jFh1mRK24se|oe>cc z#w-zNm#ku*7&i^@XAVV|>tZ|Km2a}sovC2(1Q8tBk4aBL3N-a_P})xdh*tpg5QgoJ zjw6%N2Q>BS+x%R)&V&y0nLNuajB0|(i1H)Us*XI;X*-$}(KOPA#Cl{{8; z8-s08Y0)R}(+EYo6ySxPGZ*K8+lWe6xQl->!v8pQY}J+Nbf^46C%jI&FmK}P$OW-D zq^tRc>4^scYG3c;Ow#pHZg;!$BUxs@c}J8A%;)lOc4}1tWoSsv1Chkl3C8nv)s0Ci zmA?+pg^{``W5?V!?-zuc8r+=j*>(+)N~T>b#!dg3Hf)gB?)OX7xAWdPoN_QqM14Da zKk<{E=DYVTxE@T!7y~&Pl|$1>`1~C(p8SCvCmXQN;QtocH2J?WPUKG%!HV$zdR!bB!KBrFUPAM!S8E)B0761?Y(Nuh0|kY5K@oJ2N-sQ#cF`zde|A$G#v zu}9_$RRj4OL5~-32ZG6IA=@~*Y6fcscIEFM(kD0tSv-fVcKWaUyJWJS=KqlYuP)o% zf8Q9s3u452yc95MWQpSmcD8SUQnX1)E!dQxaM!DJu=s zZyn$((Ti6t2a5?8IvvKBC5b4CPgM^-mbwp#PRiz3R3G0+`-)Um>U+5>pN#2Nw?-WY z#-ZdyQTDTStQH_6Lv8qfh|JPtMWbfqe%UQ7W-%}}E?8PYe!3-uGS)?;>5X;QU?D-F z&mAsPt*$dIlf8;D6AyILs!v|RGb7(LwEh@N)B)ku_6b?n z%WZ=Seo|ZLH2F)N+vk9i+nAw%N|MC1!OpYj}}!x^a@J5 zp-eyv_WhCWhyb}+57OvcMxh9#mJ((+s`W8#tE-x z*|51Bc8~=!YJGn>RnAD2k$$WkJuD4K8wJ25)X_Y1`wS@?g{;v=dQ!^@SeiQhxxM;( z|94W@)Jp6Q&o9GR?sqZT-P?9>Yy=cz&`dECi0eJNG1?wl_%}c!GA)5_=dgtkU38wW z!{Nq`aKyJtocn8Z>Y6t<`5lFX=>f!C(p?yt%40Kd0cg=b#u!>%2dO)D0#4q`EzQw? zU$a9{H(R6m=rB1y|Fznw@OAKpvy9jKEB>-W2TkLn)$fUH3F{2`{Sn&K|I|<; zPfWsBku`?3APB~{E}3+8ud@Ckge}QNSerdVh z^ErsJQqetBY#IIwKl-Za<#v=jWK<%1J5qD;$2wb64FKBXqXqAc@m(x$yZ5s5ho6jl> zmp{8V;RG8g>*Kz{5S_Q1&H({jQXvHt`pQc5VH@DTB&W9+9+6yH&6Ux!-;}QzW`zeT zJOMWRtw-L8y>x_^AC_I-cO==7_aE3a4H4Mp*j!9WS=Mz-4&R%04u1HPxXlksc5<<3 zGx}HFFXk4jbNQ!`AeyvR_M~CH22KM|ixgu4E0H`Bb}V=$GD1%i;7}0PU_q(rp9fNM z%k9`)64Ld{hn2!+sALx##MqrG269bcsMIsxtBrGbR9iRf2a+1&08)Yi3ubjEC0Ra} zRRRwZyE5oL!SppmSDi^?~Ta$Wa%Hk&XcLlTA)hl zFTli#15a1_{7tTJ3;_{cYTgdB>0f`x#B`QHfe>VcWGzkY39=Os=?>TQuj+zHc!x_1 zPK*&e##}-R-Qb(wlf$wsZeU^8zBP&Ei7>GrE$7t17o;Amnh#>$6tF^IXA$}^gCbBd zeprMl9iUGulX#b&D_!MgB&y&i(7S0wQ@P>vDH7<4Q*Ep^^b1M6f^!CKI7#q6MwF&# z(+s_YULqKu-DqEQMEdz;DJ#K7;YXS5%(nLV2f`Q!REi!QZf&LDg&>wu3Z&!8e5rU| zc*xJxpQQ5P^&k=w#4K1RgoQBS_+C&qb>y_w(GHFqJ8VL|YKV>R?EoL$5#=|{EYCaZ zQ+pmE&w#;TDU@H%E;|T=yHGy~qklA%tFPg&od4kx@{CPf%U)|9UR|JYOcrR<6Y2Gq zew+{;Wcs_taD^oOXe$=}?%?A)Tqf&ku1EINciv1z2I!-0ra&9qDW#ZvslprV#kTtp zr}_!tUxFD2A5jdzP7#gnriJ+lMH%2}IL>Bg(sTH!JAQM6my40Q`h>Z>zwvz7@$}um zCv9~pF#<9tH7^Bl-m5Qw#-QIY^M4~1@rfd1foSrNc@0;=x1gTd2ZanOJcdOP5)%N{ z7$4byP+zxS^5R07cd$xAjX(@HB|9MyyicSD&wTzCx>4%0{mtLWS@9Nm=N9;J;Gco7 z06ci#?%(cx^%lw!w@^IM@k8_Z&ip9ECqsAXqIxol<86+~aMYzq+w(8jXldD1c5Hf* zfk|gTOxk2hy@3r*H?7}8M%hrN2R)!SHYvciu&1^)9y*wFGL#|wYFD7ScVmBoYd^}u z4$nw*HVC*E6mAP#JxhLBuR zB_ZU5b!buzjOFTotpp%8tp=$TqxR#pQ%VMW8r1xDb*GM*re7+X(p@-L^BbJ8MPkfm z5}~nGJZ|=Ay=vcN;F-W3@$TWn_Tuj=@f10|I&^6p`6t<36W!EghQ|*p*o__6m*UY7bBv%tj(Ol%798=*j{w!VO#pn`TnEPQZzwP zd0pXqqZTT>(m&Uk_TK;|cd7Lq+>3p%?E22e-1bucoh-(Jedgze@cvBPnis)X3t3kl zi04L*$r=HeQ1nz_K@%vPsl#RiPZ?Q8l?3g?DwvLdMvmSMw(NsK!PhrdCr83D8Jjx3 zbvUdir)KkQQ3?x>pmnKClp@Sp-t8)&<5)@5nWEwj&sQ!eM{@@6; zD=%JdBG5otjh9*$HTaoA6Lu`)C%jSrGi4GRrKb6A0GR{k3~R@=5oAbb{jM?wpebAP zQEBDZa5Oqb%_gTOAf(;F@@@AZyy3hkCVJ-mHiYdd5kA9ET?jHuyk@87bQm%I@R}yp zX|TMz?}s`7bKuN8%iMYYW-zvK6MIj8Dio(DIiV25J~V&m*iyz6RsbNAl$lxH1i>$U zgvuI7VW{~yEr+d?0iE=#-a+o173L#;X^ z*BCw4908fAWkO+lR{8OA(wV0a7HzO9&irqN;{S)OzYL2q>eqnpVd(BorMtU^?yjLr zKtNg=Vd#+V4ryuWlA*g(N*W}jqy?YRd++<*@9{jJ_{Y zOrTUE(k;PBnrXMy4dW~F+jKF9+}g2;T+0dx$P?8@rolsu-MhK-W#g;b>hVbj>X^m& z^0}5<@}=ufxf`^h)CRi ze%Qplq*z<+;y8}x4==|kMUKg=58JQ7iU7H$_QhITb#t>A>G3AsLNzm5lde1HXK*8>QzxFwido#8!K<|*pqeO6A#RND zNwgmt0C4T(Iyf#w>* z@nNO_OQ7UUY;zPv%0X(qdZr%dVDxyd55qwsjfiAP?Y(R_BOlA!SU0A9U(Edv=!lIT z^c*#r`#{w!n8_@$#^?anDN)?l3(0Ig0k?aHcjbAJmd%cDiSTh9(D+boJq~1ADJ2Ut z8cSWS;DU7f2Jm{rI6jlWH6Mc&O)k85{Tb>}MKr z4^(=gzV3O+Iqvx(`SSGJIyT>HY$Eu;wxJ+<@V4D?D{oL%^xWCjJCctR`Ogavxp72m zqilMOXONDamlR(b1=*WV>AN8r%d2GeKM=&2=v)U&OI$QVV11sGEQu`l2%?K^-9crR%l1SvcVpA3EHZ217W`2!q{jeb<6YygrndIVFKkX*7KT0 z%XK_WI#fI6a5#1He;9<(mi;A?^=(}EA`9lq+9C&iV2kn${hK!Sqby1lkBKY^UK!uh@1_qr^<29^=TKn4i{63j`JtP({ym9jneof|M6LD!i-dEi20Hj(j? z$7s^JD_T`bBKT3FLB$Le3aak-hOk1o+PABuLqFh0j%Q)9=Wu+1V{scR*vY)!)-~+3 zM*IzlIYU(sW#R_kukpE=sh;=qt3P+&QfSpZrZ`1!QmL>>jym^*_i*OFHGX=@ztywI z0Z@dA0)_7XO3;7>WRrpWu{*;-_flAUIMmYX9|RHL@?>C%*{FcI=^%)cFbJ{`s`O?I zqu1xOFBE?J7lQN~kW|5OqS~)_TbMXCMbvqrQeHc#s_1P5FbFaw+cZpo^TM~KiFndH zr(M=FaD?=8aez6F<^ODMzeepbP1Sm(*qRUN}3_0NP}lbB>s|yMMh> zU|U?y^?$w6ED7nswqbDciYjt{vH)iwFblRk88%1z`fjvGX{O;1<=53K3Gs`}Rsrg1 zOI>vR?X#0lu}W$BGzzM1hfFc%88aCJpKP*xAG+;lPwXeaepQ3$;tUoeW&l!rO=Y+m zr&r|`uYAOz&QL=7){vkJZ{pe(@StDc>pkru%5dK%XB97X(AawtlKx*d3{hCnWB>{? zC#5VPTpBM-2{q(>YnZLI~ZNB4?eJOp=^2)~ZVZ(G4R>+<_7_liK(--roU zI@Ybms*A-AW9`7>-HrB;xAA=A_`SQXiQ%Ei76xGs_4hhl6AZ9IBAkn{BuQ%D6G&b1 z?5$RgU1Nz1p%b2I-N@0_o?lGA@u)yh}X?P1e8`*JdnN0IoOm)?H- zSAOE2j*^sda$U_@2mi&xe8tDc1)z_n4qyhzbDYYcCx9R1JcVnn!l;LVnt(yiC@>l9 z!QmOPs*n^BsZ^;VJx3NX*s}CCPH0~rHubOVcE3D&HOhML{b+G;$uVWQ7QIvFl~o_D zg)=L-U{g#Rs4A44UX%rl(FN)4o8fxGC18u zBA@9FvZxeHYAYVvV`1`+uzZMW8V)r+&wk0R$2_l`@q-m;E?xcm$sB7%Q*-`#7q#v( zWXfq z@xTGQH7Q-?0Ue(=s#w_dI{y$6-4^*g@9OkiPkC=EwFUWvo&ni%}_W z1XlaC#(At|uOS8Qf+FZ|-2TA}cpB$g71a3tk%T5snEP<3)r5%ub07Qvx(|+&fy)&# ziQ0eN2T%h{eA#W=pfDhc)rXLWlA;8>SV+7)C zkSpdN33)9PP8Q0^wT6+@ONud|eR*$5nSw~(H>6%NlNiAdn5^JF(CqJHY}l)k`qE|P z7x32=~MwC*^oso=)4 z8%;G>OH+`36^DDjuo-UoQPk(~D7oPpU*0TIB>M*rkfPhyGn}49m%tSX9#v**;Fas` zRUBHT#Y23Q?Kgn~BKZ{+CuaYJqEs;?t%7y&nOR1<>CD)LMM4~O9VgaQvrmZvKsF5o zWU?+;2^xAE%>)U6t(={#0m=iXC(}poy<5^S0$4F4QO49on2+KYH-kuH`Bb?Z#JR6&Pi>3$K2lXcY8-QwibB@qjX?%veAxLt;^Pe^|T#beii zg0kjphtPnqEmBjp!z8Q42pcpX6J4pYJAc4ot>sMBLDvo~DOlNHVJ4MKLb8b{dvnlZ zU=#AHmyAtEsgjc@7MBZ_c#Lhwt}>qNX^pk838o#}2Qp#A zH^AxNap6(e_0xO4&(kL|q%eAoM;iBOYCU&dSMwm!L!L+QWGXVY)pT_QtYzemJMfFo(@F!XH_G3|O*XM|v16wb_EN zg8#iY8zKdPhYh&T=wp*{zmX1Z13F88L5oEDA({{k2!oR2@*Z)+2T6HB6B0G5g^_C6 zNGNZmP4B&dVQfecV;%iyr;U{UZ>@5o&DgJPGZ4jSX0)RP{Hh(pb?2b)6~96%)$38h zp`#UkOXPx7-5}RZFzo~$#8`^*im5+mauJRh=z+!N6AkKEJWq_lOGloIkhLvt>e`z? zFPhl6yYj#77IVn{`yX1CNzg!i-+P!La!s#Pc)MHCj!#92RANi?Gc0VNZ80PzJdKXfG2|q?jt;eCYI;W)DvmKGYuqsDPbngup-e)mwSb6ed13FTiDAbA--QyBhOfL6+r@CC3YK2h*@VwZvk{iG>1q8?1c+#BYK26MBo*7uF#n0K(59q~El3Y!`cQcp`K zyfQ^y9r6Lv8W*p~k@z?~tl9$IY!bJRkk>d(~9P1@@=& zN;clIT9P zxQYG_{h_3!BR2noKP;M^Hb%H9nSi&0PoW*1pZ~tO z>AJ!*T08N#&g7fw1MLw(66R+dNHq|@?1T+2&St)q9fy|a5Lw283kG;1WYOcec5&LH z?K91Ud7*c;G~L8_TdtQ@X@B`gLuk$lEq)6lUN|EKWBIjO!sq1T^jPNqvn_;Tx$+jfFw zBDuNL;-tAI0f=VV`w@s8_W>G>5}!^u0b{TUPtAIA6C60jA@7yJ1UeInj3qnUCU^?M z4`;U)wJ0YLa$wZ}cF5FYLR$c$YQxVkdxxnnx460BC>B%b8-i6hU*UsSh%;^f`44ox zs9N{kkVp}qY^H9L5@zNzo}zJOOQQ8PS*dREGK;BwkF6le?HWK_QP`eT_0gdv< z^<`Dw5f5FTJA~&YajAstN^|=qW`+}Zrfb-Og3w3Ix-+mRztGzz)tTq_#>j;a3$9a7 zr#NTX<9nW!^b2R&$E1eE7SAiMt8dzzx+$$@h!WFtDS}jtZO=*oFCL`Wa}t4Waq0+E z!^4 z!{+d?9|6Hk#OO(-uT>`sn&Xblkn=cu|C577f%}&W~?wuKJq(B?lLgm#2fXN zki!zpb8%dT^tamPy4*mAX}5!o;$LfbOyUl;wIM!snYGwkOA4(&7L|VTww&IbXg$(0 zJYlqc4gR)+=eqmnAtC6`^dC=8<|7ijl_a%bNq)qi*9q5BPo8I%WNQxvU)JXW)JSd= zh_kNBM_1C=&uKH+VB767hx3rPEW+s{vh2f%;KFA9xj9sTwjzW`nH;sz$&usgH7Th9 zshEFW(VJ@oW)n5O>?rvi2Z%$q@e$CM{GUeZuk#y23vB$0KCndX2fNm!@#G;G}S=oZ01i$21E{m!gn_=2D5f~eG2&`xN*gM?5u8`0y>M)zZ?Xh79Ovr z_l-zDrq`TqFbJM-C*#jBy8_T59AJ_XTkIg{(p3SC_VmE7G#YVe$a6g9DFdae5U;%O z==tGuCie!_exjHjI1R=}GTRaSuLf<>;QWmS-98q>tLH+3953L*P2Kg9PD^ZzibZwh zA>$A-!ykrhvZ{b_!_ucwjrzaUOPd<%4qHDuGUwJ?p2JQY{-I`ozv3EoyPdiK0qw>V}x39!dI;lj-Ss{tS?eK5Cu=!D7|f$+ZQTecyBGb5p7 zd;~ezQO9HEh<50AwG}1=v*~L-r!uS$4pALyk0dmvE(RCkF`2}LGTnO>7=`gZmkXYI zJ<^Z5y|%*$J}|J4TVsOe4IEnkzgUn@g1^NDP4_+9mdD>%P`>yV z7DwaOWd+`+`jCAc)YS-#G1=6|2^>W@1S9=dnA~i8W4uzj6AM;=?H}sZ;!ap&fZvpr z3X3>?)9u?*MXrPX^O8bqoIxHG!Wh<~=uIZT`yVs66ZMoMEvKNHz+5S>vdzY)P8uzuvhmnEi8 zA_V*?4OIm6p*r$0&U``9pqZ{MDgm_rS|Y>|Zx|+O!ubEn1V!Um#X1u1>Iqw~2ow~z zJFI>Fy0MyKq)eI<&6@t%As<}5XQRY!-`g<^w@_ZQ4<}{0Y@Nv-h9Eyw+7jDbx2pYi z29Vf<>dAe20rvx=zD7IQ;MG-np_&ZZ__8&WLbYB~?=A6n*~q_LaPUQTBvsfWlVTlO zbtSGtW!<~3=did%_Tb@Yq?|jq&p5$RkNl6DoByk2{D-ami^3$~@ z0`=mpCaRi#jh_sPj%iG!7&+R$)9z2S2)` zhgG}5mVKOSz+U{+Z>dHjaiLp{-9JiSm)o}>)FH=>>5*Juz+dB5<{`Ik5xR(2i*EM5!0w_ivi-ezQsVV>;$`ZbqeE$TH)V)4 z2#Mw?{6G{*{(V+f=Aucx<3}Fp0S#RcDU?ha;R2AlgH7|n-8RnO9v**gC zjyCg)ss!I6{48V1mS?fCLYv`?VFTT8aR z4Yo<<4MU+uDX#`Lt)fp* zNfJd8?fwwxw~v;`z?Kp30nPCi{#MOVGY1vlgKx^C);PXPkVxIfuszb0q>c{iz<%8| zG{gu6MRK@d#t>ReGl!;VL=zla4A7@}qByWc7NGytc5)1AE@YQF7HERVeD!TK-^aD1jDb$;kkO1vpmtz>_0MQfT{x@cT+ zNtbhiK1L4k52|RrAYl%j$q#X|`|uC^ZxCq7=iBgByW#0zCL}7k8UcjgW$lNxLJlp# z*Hmiaz;cVv3YM!fy8c1~Txcq>e8t?n+-UB!Hk3D7daU}&oyk{Dazz2NfZ7OM?R;3o z$^}whNSa<*vOtVJgi^iHDL1qpsmJLvkLuHU!G?iqSXoGgH}?NFp(KTcL!mFFPB!1g zXoX8H@o2uhwpVhQ*NEMLU#W#J!GqV}dA&lScTPWgugZ~vYE1RX<-XRmL(HttW{VF= z{=m1m&9=HhTZxhaxhqN=E;2;OICu0K^lBa9*n6#gFSP9V*yM`T_5{A|*X*PpVKoNh zyA9E{U$CD}mNw77AE@=)u2-ytZ0Uart%I6dHpTAOF1A#t_NPrJy@R2RpQ>RdGd zlP&!+n7a#Hte?F}EM|PGsEqU>E2KcqqJ@BRU?esRnVIoNon3}@OL%)UKR}k7*dM9xuJeA4t~WM^jXkVNf(2D)eqYjxqAL-X-r@*%5d&1HX4MMJ;HhjEuQxU8{jx)|2mXl>}DEEFsy=Lk$dDTj)GDpW7!1<3u63Sq#~BgDsjJsu9= z%_<8uL;4m^jeLji>1PY?9dL*>JVCOk^(6NwGm6PAvDpl*OKI490=l2CB2$B@-8)fdD~aQr{gIj@cN}xL2Y5N zca3*q5jjltuL36iASJ)W`tp15DdVeRdVz>Sm;J?ESugF2+pS$soTO-c_8;F`2Us3R z>=|J}cWi0c*y?lOs^bq9BIS@Z>MDUFGETJ}%3Wse(ye>hU^C^uR@dtf?dV?X$HH+o z-1)i4%X->BO{{-rB1Li&$vTl}{=5fgdrq!6DfMzegxyUAb||^^R+kR+l`AQsI0dC`F~YtNY9&mVc01YR>x;DJIFgRfjpp};0&$G-QX426;BK5 z@giSnjj3@?e;}>iIkd`Zln7V5J(=~!Xlp6I+=h*55WYDXeIA86et-O6dy!_a9F+wS z-FB=6kf(YWZ3bYWg!#k*9(*j-)Wcj1T3_==*H-Vzg}|+L=~t(P$N>sffNiNT83Gyp zl_B`120mCQDEWUwK{ssR!xncte&B40ow+KXA-+x?z7q z&C^@wxvseEI3_yJvPFUh#s7V=S&y-h<@{z+>*HW&YLU|EEHLhX12N@fWVd&Q@e)%dapmdRZ0E!x5mSA(%<4 z^6G&oDMaw&yYSGbG@WZkNpn>nL7NYIWz`Ck<8=eO1TZ_GyE-E35`p(0^7P&omF(_Z7+)>>0@?Mnof?niew&W=xGh zNr@4tgxlMd0*z*j^*4t*%ndmv1?faqC>~1Ap=d;&+7t_!A zXlLWTPRdh8ixvorv7n1>&41ECrhrFSI%wGUZ#oDs6|Oa*=bfLwoaARhKjUv~Q+WEh z8#yOUM!`r%NhAhHu*sElsQ_1Nq>B{S4-Auu2%K7AmuLjcNW;U;LrUC@hO=qb@y#KW z@1)Au1l*RWx@+l5#)VJt7~d%D(#4^@^l9GCc71Nx7?`~ug9RkG?y?nQ~>tkXJyW9 zpg)f~g@uC}&a>WkDjhTOWEOlZnJRbRzdc#L!@iTqt7|c^@=kl+nG51M?QE$n(D;Pv zOyjYTMOeWPw^`cuxzuQw#l{9@1+smiVz_g|wr#*w6EiG5w)c=FzAuD#1Iq{H{oi~L za$kt*!2mCJB*H8vKzNYxSiH#mo7Z_9li}OI79Mv)!mYrNzF6TDgX$O-`Lgu(@u;N= zSFSC$Gr;`ce2^P*fJA~B(sEHSH*)Va2#H~cKqVw=VpLyK%nMjg_M1O_-`{!_DVL8unNzkO@v*SnKKJ~>+sp+FXM)uH%+4}pSKPL&ekFl^@$1m0| zK~oPey9M4alAP56VW_=I;|(ObnRbmGsTRc5cS$z3o=1x7S8zz03_C37Pvj)-qkYACCC|Lo16czo?~V_4OEUGnM| zzig_s%f?s^dLM1n3q*QCavtzC3cc~KNg`c_%fz zZK0eU38(;a`;kRUg;U?vo(b$k_1;J&)Xd&z34cz&^SC1H({u+a|ks$O?)Y^#L zQZR3S9o)@J11?f)HVk)t8|Fd-*`Ih*SOE2bqkkHu2LY9~K9%L6qug zJflA8AbFcS)}2*kbBml0$B-hb&~E{gsrtxQtg=k@;}$%1o3A0}zZl}HI4-Ihn*wtv zhbJ*0+I=}2NCtnGF z2%mijvm|_#tJ5b_;u$V2k@QKD)jg7A7wyu2`dz=Eb!-9Jme;QfJ2~v@^W^46->36X z9IvU9v-JfA_W^ZO6gJf>7A5H=@ISKmWMmT;ZhA zg;Ln6r2=dWAnEld9jCM$MD#X1AY-L-1v-v)Be0Fs38+ToIMvuQw`TiuE?mjH>yek{ zxpWy!w?Nx|AjbBx>)=CI-3y_^`DQgriEU9v@hg!0w{T1TOTca4Qq>)*#(FRaAO~?T zGZ$Yb`Di{36%4kU%yw`JyGeZoY6F>zBLf>N)R+vSH|3~AGF2wD{L_JGS>9l3A4(j~ zCj3`FX8?m#aO!GAf?SUc&M1s(14RKlXdaiSLQmBpl&-ggW48!X60i?5AIl)>yMILA zbFIls#9@$-nE7?*(?cS{AN0u9c@1LvheH*Th97=XpT6g(>0nbE?Fx*$V(OYvVY3aY z6XsM0Ud2U1tZRZlfzz}j$-}>QdE)hPs$hqYuA0zzm2c@dbTz17e^IqSd55ZQcVA6W zAfBV_{OW^z&IqzJD>&JaCFEJRj$3KQ&DzBU zySaAe`+_tUDs`CXot}(QM_=@C8N6K;<5>qLsetpa2V}rIy)NPsaP#_d-0_*#IWz@5YBUL zKLm5N2jlG@ecH#D7OZJ%jERgXm+}e@5i+m>xPjSU0-T6Xa6{fFjA=S);Hx7Gqyo!{ zrh?hFRGJ;@Q7`aZ;#4lG7Rt08UGe+vIKviz1RX$$U-^-OTBI8qE5zJObS-4`n%+vU z27>8p_gas}MhNx${Ct8m8{Uo2UMsx;kYMuOhmB>mTaxQBkC{NZEtJ0~BE3EcZni`o z+NlvnMcCS8@(HC*9CNQeepnZPPLNjWQ@b)-BevdHz(KT_vYr$ZnTJg*B&2l9Hqa&b z-m$tJ+k)!ot8GdTI(U}U=a+yFB4(vuZMDcr>j03u1byMMFSGG+p!Di+0@kJi` z9-hxz^qGcuVKgG!_R^4uH!H!ZgcZC(Hc<;9iQ)t$x%{HYK7rw=k6~-Wc6yhtn(pC7 z5+1O&xe-b)xA6P!U0djy)R@1~?$3+eX*9`$yW~^WDa=5&kDKky!&6vhL<}yUyFUaL z){SQtyplbyO2^st$}v0m7Rv-dkoscJz61g>;7_G&i?i(_llDZhD_UzIU`RRYgugO# zYErk)GGFN1#qX7lhchX|^y+pP9X&5_up6h3+q&uf71$=Zyp+AnJGUt}SRUhTQ3l+5 zW9s2FhrFl=)u|61Z1R7?QWGB}WjX=Y1DE~az-UFQD0F(OMjKnwdZ^R|`AdlVd|HfZ zgs16R9?Bo~cIFQrkcMtJQVTlx?+my$loJFT!9*^CW^2H!`J$pGFmd2vD^+k>y)>H( z+!A~_4X|%0ouB=}q;f)cnGZi)kk^IjbETy*GY5326j8&fZZWDm`Hoi&G(2w$e}%UF zDl>4&q$|uTBQt)w4eGBwiN(lbP_d40hiWJH)3ssi?^|f=BX%dae)c&->TW!~ZAS)+ zaTV~PneCC`durnSypNGOsBV`Jb74r^CtOA>7pAFmt|og(IpG>}z*o$vj+7!wu3 zxl~CFyALf0?P4HO`k%At?KsktmQ1I)b60Ts{6BZqsSFDxW8Vq-z2uhu})eYqL34LNwYC^AX zex`%^2zZ`iJA>^i-w6FcdwfesRcaS6A(e{(>xm4OXPG?NC6o~5W9xWq5#|d6 zC#k1h7P}yF#-_fB)ODB5I=KDJ>Ru(~pju*S4|+2z;#-V4e8-I;lq>D3?IR>pv{L^t zLYYwMO7pTUf~<)A=shqeQl^}`!v6!`JMM6`<4WZ7wfgpk$bHl6LiJxtV3{%tTGmLb z{5lgTx>|6akX=8=1(Omu`St+w<5pQZqFXwd7e$%$B1pwLe&LA%)g|f}Wvxl!{$S^a zELfGCd7!f#-TwmG<8c8sq;&&r8<50m2QWPYn?bsHt+3btT16inU_Wa)9XdbsM5`Y~(gzI%*vyJ|0g8 z*L#U=J}Bd7gt7jRgY7{M!YJ!OD0Bbm(_2-hKNlssihN|Q3SW>k(7owN_ojJoEL(?q zFJ|_idk4=hEKZJ4HAQ=CXDLa23r2AQDxBVt##6Th2-^fd7##|wDWoI0BH$_pTb?$P zf}D^Rird4Wif|zmqp^TaKoXkT3kqTyzqan) z3wG05w$>_`*{g2&f4`ynFe9Feye?bOT`%~gZUT}#-!mopeF2#_;mb6nPui#28H?^F zw4B~dPN-lYal%t_g9O|g+cQwa!W!UFbj;op0r`uMbp(mtolNF&q+7rL#4pclnv1-t z)gR+}HF;QPgrqz~#*2Ge;zRqG_P)2M1&C4@h&-s!h*ixDXAh}2(~m#&qGAW8+gxmp zjG272&E?)_E+o0d^_cF?@J|fHmcA#(mKJhkGn4L8!5C)DWzW^Cr#0yTefzpe6ZYM+ zrC#f0S^j~{T!x6+ZEL3gq{5c*>+NaSAB2vteizU~`lVu=t}qwD6(e&}ggzcC=Sn!h z7NSQQl89&BXZDZQC8;rCUG5~Pl8DA3hXJb-vr2Uz$xu?sb8YJ=O-2X^7R*ltX(O%L zXAKcW?nDscPokM*=a-hz{hEh(?1(j|NruSHu@U45nN>B76wtu(@03N-KD6mu?T@aY zgA_BxQ!Rb?yirq{YZlo!IV=bA-Ax;%sKSW7<{@RkC@#7gH0kctzDwt(FNe$l!M8=~C{?h2<~_U0cYIBhFTXFL`Sh(&mfxc3_Kw(k zK{NlAl_2XNL9b!IbL@9@3qiH*n`+{>bdi6U#=iRLCeHH0xie$V7iv4i;|VMuFWwurxNZSF|SLt#UQ$(lkumVlMrB@28H> zf^m8d`DnZ8ov8SsuMZ1pRIa4T>sx)3G>}625oa&Nk0stmMJl53g?|5-llRP)wIL`~ z-~iA^AH66_R8u+g1@ukQZ>6p5S%QO`DYkC)I;HwCUb;N{(em5OyWcv_8D}<3tn>J2 zxeVg0{IYO>Gr3&22C&-Z*aSNlL-SY(L+5`<-x<2NR`o}0KGthi7RL%h)`4vWZHhjP!VYR;K0XmK+A-aOd^zBekBy#Av%{bK43|vWp*q->RQ8J~%V;h(rF3F+ z4*fg`0I9})tf^-dfW7H0-CBTkfRExMn1s`2R4C+=^ zVq}Y>VoTgYXvBTHy~__$qkx$_aQh@%4CEKX0~#8YBW> z-}DRhloqU$SqNw5!y0~$QM?RhYb1WUW~mPlc|Q>!nLdaUVyHr8wOAL`$0jWc9cR-N z>JbrkWOcGgVg4?2sMDJMa?Av4c+fSTQJx(K*_xELn2eP)LuD_4p7SNew5pXYEMPPf z{a(%i?m+awQTGFeYNoq43{FTDG`G9mAx)g>wY&EP1i`k!ElBK~@XR2c>xP^;ySRbN zKu$|?8qc97 zu4-!ET*eS$483KzhtkZo68+I<;1+b2^#h!s-zZ{j`Cstivo5-nt(jlReh55TWrP1> z;Z~^yms9U_%D-v^a)Zr<&};%lA;ZZjVf9&T-U+ znddu;_≪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

  1. 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
    #Q+oa>WP8fw~Pp8Ucr6b3ZXxkHOgc`GPX8|B@ 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 F{tv{h3d8^a literal 0 HcmV?d00001 diff --git a/testcases/typed-data.json.gz b/testcases/typed-data.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..afe593ccbe2e5cfc9952a35ddfd3275890276b94 GIT binary patch literal 40762 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

    2. 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Յ|Eb7Du3P2FQA*WPk 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