diff --git a/admin/cmds/spell-check.js b/admin/cmds/spell-check.js new file mode 100644 index 0000000000..b15bb77b80 --- /dev/null +++ b/admin/cmds/spell-check.js @@ -0,0 +1,213 @@ +"use strict"; + +const { resolve } = require("path"); +const fs = require("fs"); + +const Words = fs.readFileSync("/usr/share/dict/words").toString().split("\n").reduce((accum, word) => { + accum[word.toLowerCase()] = true; + return accum; +}, { }); + +` +// Words missing from the dictionary +addresses aligned autofill called cancelled censored compiled +computed configured consumed creating decoded +decoding decrypt decrypted decrypting deployed deploying deprecated +discontinued earliest email enabled encoded encoding encrypt +encrypted encrypting entries euro exceeded existing expected expired +failed fetches formatted formatting funding generated +has ignoring implemented implementer imported including instantiate +keyword labelled larger lookup matches mined modified modifies multi +named nested neutered numeric offline optimizer owned packed padded parsed parsing +passed placeholder processing reached recommended recovered redacted remaining replaced +required serializes shared signed signing stored supported +tagging targetted transactions uninstall unsubscribe using verifies website + +// Overly Specific Words +BIP BIP39 BIP44 crypto eip hashes hmac icap +keccak namehash ripemd RLP scrypt secp sha + +blockhash + +bitcoin ethereum finney gwei kwei mwei satoshi szabo wei weth + +crowdsale hexlify hd hdnode underpriced + +boolean int struct tuple uint +nonpayable +jumpdest mstore shr shl xor + +// Classes +ABIEncoder testcase numberish Wordlist + +// Common Code Strings +abi addr api app arg arrayify asm basex +bigint bn byte bytecode callback +calldata checksum ciphertext cli codepoint +config contenthash ctr ctrl debug dklen eexist encseed +eof ethaddr ethseed ethers eval exec filename func +gz hid http https hw iv info init ipc +json kdf kdfparams labelhash lang lib +multihash nfc nfkc +nfd nfkd nodehash oob opcode pbkdf pc plugin +pragma pre prf repl rpc sighash topichash solc +stdin stdout subclasses subnode timeout todo txt +ufixed utc utf util url uuid +vm vs websocket wikipedia wx xe zlib + +// AbiV2 +abiv + +// Query parameters +apikey asc endblock startblock + +Cloudflare Etherscan INFURA IPFS Nodesmith Trezor ledgerhq +axic bitcoinjs browserify easyseed ethereumjs +goerli homestead kotti kovan mainnet morden mordor rinkeby ropsten testnet + +// Demo words +args foo eth foo foobar ll localhost passwd ricmoo tx xxx yna + +// nameprep tags +ALCat BiDi LCat nameprep + +// Lanauge Codes (and short binary data) +cn cz en es fr it ja tw zh zh_cn zh_tw +OYAa IJBEJqXZJ + +`.split("\n").filter((l) => (l.substring(0, 2) != "/\/")).join("\n").split(/\s+/g,).forEach((word) => { + word = word.trim(); + if (word === "") { return; } + Words[word.toLowerCase()] = true; +}); + +const ts = require("typescript"); + +function getStrings(source) { + const sourceFile = ts.createSourceFile("filename.ts", source); + + const result = [ ]; + + function add(value, pos) { + const lineNo = sourceFile.getLineAndCharacterOfPosition(pos).line + 1; + result.push({ value, lineNo }); + } + + let lastClass = null, lastEnum = null; + function visit(node, depth) { + switch (node.kind) { + //case ts.SyntaxKind.TemplateExpression: + // if (node.head) { visit(node.head); } + // console.dir(node, { depth: null }); + // break; + case ts.SyntaxKind.TemplateHead: + case ts.SyntaxKind.TemplateMiddle: + case ts.SyntaxKind.TemplateTail: + case ts.SyntaxKind.StringLiteral: + case ts.SyntaxKind.NoSubstitutionTemplateLiteral: + add(node.text, node.pos); + break; + } + + ts.forEachChild(node, (node) => { return visit(node, depth + 1); }); + } + + visit(sourceFile, 0); + + return result; +} + +const Include = new RegExp("packages/.*/src.ts/.*\.ts$"); +const Exclude = new RegExp("/node_modules/|src.ts/.*browser.*"); + +function getAllStrings(path) { + const Root = resolve(__dirname, path); + + const readdir = function(path) { + if (path.match(Exclude)) { return [ ]; } + + const stat = fs.statSync(path); + if (stat.isDirectory()) { + return fs.readdirSync(path).reduce((result, filename) => { + readdir(resolve(path, filename)).forEach((file) => { + result.push(file); + }); + return result; + }, [ ]); + } + + if (path.match(Include)) { + const source = fs.readFileSync(path).toString(); + return [ { filename: path.substring(Root.length), values: getStrings(source) } ] + } + + return [ ]; + } + + return readdir(Root); +} + +function checkWord(word) { + word = word.toLowerCase(); + + // A word + if (Words[word]) { return true; } + + // Simple Plural + if (word.match(/.*s$/) && Words[word.substring(0, word.length - 1)]) { return true; } + + // Hex string + if (word.match(/^(0x)?[0-9a-f]*$/i)) { return true; } +} + +function starts(text, prefix) { + return (text.substring(0, prefix.length) === prefix); +} + +(async function() { + let count = 0; + getAllStrings(resolve(__dirname, "../../packages")).forEach((file) => { + if (starts(file.filename, "/testcases/src.ts/generation-scripts")) { return; } + if (starts(file.filename, "/asm/src.ts/opcodes.ts")) { return; } + + file.values.forEach((entry) => { + function problem(word) { + count++; + console.log({ + filename: file.filename, + word: JSON.stringify(word), + sentence: JSON.stringify(entry.value.substring(0, 80)), + line: entry.lineNo + }); + } + + const value = entry.value.trim(); + + // Emptry space + if (value === "") { return; } + + // Prolly a require + if (value.match(/^@ethersproject\/[a-z0-9-]+$/)) { return; } + if (value.substring(0, 2) === "./") { return; } + + // Prolly encoded binary data + if (value.indexOf(" ") === -1 && value.length > 20) { return; } + + if (checkWord(value)) { return; } + + value.replace(/([a-z+])([A-Z])/g, (all, first, secondLetter) => { + return first + " " + secondLetter; + }).replace(/((?:0x)?[A-Za-z]+)/gi, (all, word) => { + if (checkWord(word)) { return; } + problem(word); + return ""; + });; + }); + }); + if (count) { + console.log(`Found ${ count } typos.`); + process.exit(1) + } + process.exit(0) +})(); + diff --git a/docs.wrm/documentation/index.wrm b/docs.wrm/documentation.wrm similarity index 100% rename from docs.wrm/documentation/index.wrm rename to docs.wrm/documentation.wrm diff --git a/docs.wrm/migration/ethers-v4/index.wrm b/docs.wrm/migration/ethers-v4.wrm similarity index 100% rename from docs.wrm/migration/ethers-v4/index.wrm rename to docs.wrm/migration/ethers-v4.wrm diff --git a/docs.wrm/migration/web3/index.wrm b/docs.wrm/migration/web3.wrm similarity index 100% rename from docs.wrm/migration/web3/index.wrm rename to docs.wrm/migration/web3.wrm diff --git a/package.json b/package.json index 58e9223a1f..7df32c517b 100644 --- a/package.json +++ b/package.json @@ -32,8 +32,9 @@ "lock-versions": "node ./admin/cmds/lock-versions", "build-docs": "flatworm docs.wrm docs", "upload-docs": " node ./admin/cmds/upload-docs.js", + "spell-check": "node admin/cmds/spell-check.js", "_admin_prepare": "npm run clean && npm run bootstrap && npm run build && node ./admin/cmds/update-exports.js", - "update-versions": "npm run _admin_prepare && node ./admin/cmds/update-versions", + "update-versions": "npm run spell-check && npm run _admin_prepare && node ./admin/cmds/update-versions", "publish-all": "node ./admin/cmds/publish", "sync-github": "node ./admin/cmds/cache-github" }, diff --git a/packages/abi/src.ts/fragments.ts b/packages/abi/src.ts/fragments.ts index 1c7006c19d..5065058661 100644 --- a/packages/abi/src.ts/fragments.ts +++ b/packages/abi/src.ts/fragments.ts @@ -566,7 +566,7 @@ function parseGas(value: string, params: any): string { logger.throwArgumentError("invalid human-readable ABI signature", "value", value); } if (!comps[1].match(/^[0-9]+$/)) { - logger.throwArgumentError("invalid human-readable aBI signature gas", "value", value); + logger.throwArgumentError("invalid human-readable ABI signature gas", "value", value); } params.gas = BigNumber.from(comps[1]); return comps[0]; @@ -938,7 +938,7 @@ function splitNesting(value: string): Array { } else if (c === ")") { depth--; if (depth === -1) { - logger.throwArgumentError("unbalanced parenthsis", "value", value); + logger.throwArgumentError("unbalanced parenthesis", "value", value); } } } diff --git a/packages/abi/src.ts/interface.ts b/packages/abi/src.ts/interface.ts index 213c4f57f7..260592be19 100644 --- a/packages/abi/src.ts/interface.ts +++ b/packages/abi/src.ts/interface.ts @@ -119,7 +119,7 @@ export class Interface { format(format?: string): string | Array { if (!format) { format = FormatTypes.full; } if (format === FormatTypes.sighash) { - logger.throwArgumentError("interface does not support formating sighash", "format", format); + logger.throwArgumentError("interface does not support formatting sighash", "format", format); } const abi = this.fragments.map((fragment) => fragment.format(format)); diff --git a/packages/asm/src.ts/assembler.ts b/packages/asm/src.ts/assembler.ts index 225384e3bc..ce91f14927 100644 --- a/packages/asm/src.ts/assembler.ts +++ b/packages/asm/src.ts/assembler.ts @@ -205,7 +205,7 @@ export abstract class Node { }; const factory = Factories[options.type]; - if (!factory) { throwError("uknown type: " + options.type, options.loc); } + if (!factory) { throwError("unknown type: " + options.type, options.loc); } return factory.from(options); } } diff --git a/packages/bignumber/src.ts/bignumber.ts b/packages/bignumber/src.ts/bignumber.ts index 39dadedd40..d2c2b4831b 100644 --- a/packages/bignumber/src.ts/bignumber.ts +++ b/packages/bignumber/src.ts/bignumber.ts @@ -42,7 +42,7 @@ export class BigNumber implements Hexable { logger.checkNew(new.target, BigNumber); if (constructorGuard !== _constructorGuard) { - logger.throwError("cannot call consturtor directly; use BigNumber.from", Logger.errors.UNSUPPORTED_OPERATION, { + logger.throwError("cannot call constructor directly; use BigNumber.from", Logger.errors.UNSUPPORTED_OPERATION, { operation: "new (BigNumber)" }); } diff --git a/packages/bignumber/src.ts/fixednumber.ts b/packages/bignumber/src.ts/fixednumber.ts index 1ee803b326..54ed796336 100644 --- a/packages/bignumber/src.ts/fixednumber.ts +++ b/packages/bignumber/src.ts/fixednumber.ts @@ -232,7 +232,7 @@ export class FixedNumber { round(decimals?: number): FixedNumber { if (decimals == null) { decimals = 0; } if (decimals < 0 || decimals > 80 || (decimals % 1)) { - logger.throwArgumentError("invalid decimal cound", "decimals", decimals); + logger.throwArgumentError("invalid decimal count", "decimals", decimals); } // If we are already in range, we're done diff --git a/packages/cli/src.ts/bin/ethers-ens.ts b/packages/cli/src.ts/bin/ethers-ens.ts index 765c5cd821..4ab6901061 100644 --- a/packages/cli/src.ts/bin/ethers-ens.ts +++ b/packages/cli/src.ts/bin/ethers-ens.ts @@ -237,7 +237,7 @@ abstract class AccountPlugin extends EnsPlugin { nodehash: string; static getHelp(): Help { - return logger.throwError("subclasses must implemetn this", ethers.errors.UNSUPPORTED_OPERATION, { + return logger.throwError("subclasses must implement this", ethers.errors.UNSUPPORTED_OPERATION, { operation: "getHelp" }); } @@ -841,7 +841,7 @@ class ReclaimPlugin extends AddressAccountPlugin { try { ownerOf = await registrar.ownerOf(ethers.utils.id(comps[0])); } catch (error) { - this.throwError("Name not present in Permantent Registrar"); + this.throwError("Name not present in Permanent Registrar"); } if (account !== ownerOf) { diff --git a/packages/cli/src.ts/bin/ethers.ts b/packages/cli/src.ts/bin/ethers.ts index 758959971b..11a9cf8a30 100644 --- a/packages/cli/src.ts/bin/ethers.ts +++ b/packages/cli/src.ts/bin/ethers.ts @@ -421,7 +421,7 @@ class SendPlugin extends Plugin { await super.prepareOptions(argParser); if (this.accounts.length !== 1) { - this.throwUsageError("send requires exacly one account"); + this.throwUsageError("send requires exactly one account"); } this.data = ethers.utils.hexlify(argParser.consumeOption("data") || "0x"); @@ -464,7 +464,7 @@ class SweepPlugin extends Plugin { await super.prepareOptions(argParser); if (this.accounts.length !== 1) { - this.throwUsageError("sweep requires exacly one account"); + this.throwUsageError("sweep requires exactly one account"); } } @@ -529,7 +529,7 @@ class SignMessagePlugin extends Plugin { async prepareOptions(argParser: ArgParser): Promise { await super.prepareOptions(argParser); if (this.accounts.length !== 1) { - this.throwError("sign-message requires exacly one account"); + this.throwError("sign-message requires exactly one account"); } this.hex = argParser.consumeFlag("hex"); } @@ -741,7 +741,7 @@ class UnwrapEtherPlugin extends Plugin { let address = await this.accounts[0].getAddress(); this.dump("Withdrawing Wrapped Ether", { "To": address, - "Valiue": ethers.utils.formatEther(this.value) + "Value": ethers.utils.formatEther(this.value) }); let contract = new ethers.Contract(WethAddress, WethAbi, this.accounts[0]); diff --git a/packages/cli/src.ts/cli.ts b/packages/cli/src.ts/cli.ts index 2b4c891187..129f5ae96e 100644 --- a/packages/cli/src.ts/cli.ts +++ b/packages/cli/src.ts/cli.ts @@ -878,7 +878,7 @@ export class CLI { console.log(" --gasPrice GWEI Default gas price for transactions(in wei)"); console.log(" --gasLimit GAS Default gas limit for transactions"); console.log(" --nonce NONCE Initial nonce for the first transaction"); - console.log(" --yes Always accept Siging and Sending"); + console.log(" --yes Always accept Signing and Sending"); console.log(""); } diff --git a/packages/contracts/src.ts/index.ts b/packages/contracts/src.ts/index.ts index cfd0bcb1c6..fc460f8d44 100644 --- a/packages/contracts/src.ts/index.ts +++ b/packages/contracts/src.ts/index.ts @@ -147,7 +147,7 @@ function runMethod(contract: Contract, functionName: string, options: RunOptions // Check for unexpected keys (e.g. using "gas" instead of "gasLimit") for (let key in tx) { if (!allowedTransactionKeys[key]) { - logger.throwError(("unknown transaxction override - " + key), "overrides", tx); + logger.throwError(("unknown transaction override - " + key), "overrides", tx); } } } diff --git a/packages/errors/src.ts/index.ts b/packages/errors/src.ts/index.ts index fdb00ca586..ff4c31e22c 100644 --- a/packages/errors/src.ts/index.ts +++ b/packages/errors/src.ts/index.ts @@ -281,7 +281,7 @@ let LogLevel = LogLevels["default"]; export function setLogLevel(logLevel: string): void { let level = LogLevels[logLevel]; if (level == null) { - warn("invliad log level - " + logLevel); + warn("invalid log level - " + logLevel); return; } LogLevel = level; diff --git a/packages/ethers/src.ts/utils.ts b/packages/ethers/src.ts/utils.ts index e9ac35b831..a21441d5a2 100644 --- a/packages/ethers/src.ts/utils.ts +++ b/packages/ethers/src.ts/utils.ts @@ -9,9 +9,9 @@ import { defaultPath, entropyToMnemonic, HDNode, isValidMnemonic, mnemonicToEntr import { getJsonWalletAddress } from "@ethersproject/json-wallets"; import { keccak256 } from "@ethersproject/keccak256"; import { Logger } from "@ethersproject/logger"; -import { sha256 } from "@ethersproject/sha2"; +import { computeHmac, ripemd160, sha256, sha512 } from "@ethersproject/sha2"; import { keccak256 as solidityKeccak256, pack as solidityPack, sha256 as soliditySha256 } from "@ethersproject/solidity"; -import { randomBytes } from "@ethersproject/random"; +import { randomBytes, shuffled } from "@ethersproject/random"; import { checkProperties, deepCopy, defineReadOnly, getStatic, resolveProperties, shallowCopy } from "@ethersproject/properties"; import * as RLP from "@ethersproject/rlp"; import { computePublicKey, recoverPublicKey, SigningKey } from "@ethersproject/signing-key"; @@ -119,10 +119,14 @@ export { commify, + computeHmac, keccak256, + ripemd160, sha256, + sha512, randomBytes, + shuffled, solidityPack, solidityKeccak256, diff --git a/packages/experimental/src.ts/eip1193-bridge.ts b/packages/experimental/src.ts/eip1193-bridge.ts index b667db6c95..c3ad6c6652 100644 --- a/packages/experimental/src.ts/eip1193-bridge.ts +++ b/packages/experimental/src.ts/eip1193-bridge.ts @@ -86,7 +86,7 @@ export class _Eip1193Bridge extends EventEmitter { } case "estimateGas": { if (params[1] && params[1] !== "latest") { - throwUnsupported("estimateGas does not supprot blockTag"); + throwUnsupported("estimateGas does not support blockTag"); } const req = ethers.providers.JsonRpcProvider.hexlifyTransaction(params[0]); diff --git a/packages/hardware-wallets/src.ts/ledger.ts b/packages/hardware-wallets/src.ts/ledger.ts index b64daeb071..cd50c50688 100644 --- a/packages/hardware-wallets/src.ts/ledger.ts +++ b/packages/hardware-wallets/src.ts/ledger.ts @@ -36,7 +36,7 @@ export class LedgerSigner extends ethers.Signer { ethers.utils.defineReadOnly(this, "provider", provider || null); const transport = transports[type]; - if (!transport) { logger.throwArgumentError("unknown or unsupport type", "type", type); } + if (!transport) { logger.throwArgumentError("unknown or unsupported type", "type", type); } ethers.utils.defineReadOnly(this, "_eth", transport.create().then((transport) => { const eth = new Eth(transport); diff --git a/packages/providers/src.ts/etherscan-provider.ts b/packages/providers/src.ts/etherscan-provider.ts index d6af9d6e77..a83b49dd92 100644 --- a/packages/providers/src.ts/etherscan-provider.ts +++ b/packages/providers/src.ts/etherscan-provider.ts @@ -200,7 +200,7 @@ export class EtherscanProvider extends BaseProvider{ url += apiKey; return get(url); } - throw new Error("getBlock by blockHash not implmeneted"); + throw new Error("getBlock by blockHash not implemented"); case "getTransaction": url += "/api?module=proxy&action=eth_getTransactionByHash&txhash=" + params.transactionHash; diff --git a/packages/providers/src.ts/formatter.ts b/packages/providers/src.ts/formatter.ts index c89d7fa18f..f57767a3cb 100644 --- a/packages/providers/src.ts/formatter.ts +++ b/packages/providers/src.ts/formatter.ts @@ -180,7 +180,7 @@ export class Formatter { if (value === "true") { return true; } if (value === "false") { return false; } } - throw new Error("invaid boolean - " + value); + throw new Error("invalid boolean - " + value); } hex(value: any, strict?: boolean): string { diff --git a/packages/providers/src.ts/websocket-provider.ts b/packages/providers/src.ts/websocket-provider.ts index d82414fda1..9fdf74f081 100644 --- a/packages/providers/src.ts/websocket-provider.ts +++ b/packages/providers/src.ts/websocket-provider.ts @@ -161,7 +161,7 @@ export class WebSocketProvider extends JsonRpcProvider { } static defaultUrl(): string { - return "ws:/" + "/localhost:8546"; + return "ws:/\/localhost:8546"; } async _subscribe(tag: string, param: Array, processFunc: (result: any) => void): Promise { diff --git a/packages/tests/src.ts/test-contract-interface.ts b/packages/tests/src.ts/test-contract-interface.ts index b31ebf5238..9cf9fcae01 100644 --- a/packages/tests/src.ts/test-contract-interface.ts +++ b/packages/tests/src.ts/test-contract-interface.ts @@ -122,7 +122,7 @@ describe('ABI Coder Encoding', function() { let title = test.name + ' => (' + test.types + ') = (' + test.normalizedValues + ')'; - it(('encodes paramters - ' + test.name + ' - ' + test.types), function() { + it(('encodes parameters - ' + test.name + ' - ' + test.types), function() { this.timeout(120000); let encoded = coder.encode(types, values); assert.equal(encoded, result, 'encoded data - ' + title); diff --git a/packages/tests/src.ts/test-utils.ts b/packages/tests/src.ts/test-utils.ts index e7b13c1ce9..cc98750443 100644 --- a/packages/tests/src.ts/test-utils.ts +++ b/packages/tests/src.ts/test-utils.ts @@ -218,7 +218,7 @@ describe('Test Namehash', function() { }); }); -describe('Test ID Hash Functione', function () { +describe('Test ID Hash Functions', function () { type TestCase = { expected: string, name: string, @@ -328,7 +328,7 @@ describe('Test Base64 coder', function() { let decoded = ethers.utils.toUtf8Bytes(decodedText); let encoded = 'TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlzIHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2YgdGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGludWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRoZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4='; assert.equal(ethers.utils.base64.encode(decoded), encoded, 'encodes to base64 string'); - assert.equal(ethers.utils.toUtf8String(ethers.utils.base64.decode(encoded)), decodedText, 'decodes from base64 sstring'); + assert.equal(ethers.utils.toUtf8String(ethers.utils.base64.decode(encoded)), decodedText, 'decodes from base64 string'); }); }); @@ -442,7 +442,7 @@ describe('Test Bytes32String coder', function() { }); describe('Test BigNumber', function() { - it("computes absoltue values", function() { + it("computes absolute values", function() { function testAbs(test: { expected: string, value: string }) { let value = ethers.BigNumber.from(test.value); let expected = ethers.BigNumber.from(test.expected); diff --git a/packages/tests/src.ts/test-wallet.ts b/packages/tests/src.ts/test-wallet.ts index b34d85ed34..299b7fdf64 100644 --- a/packages/tests/src.ts/test-wallet.ts +++ b/packages/tests/src.ts/test-wallet.ts @@ -46,7 +46,7 @@ describe('Test JSON Wallets', function() { assert.equal(decryptedWallet.address, wallet.address, 'decrypted wallet - ' + wallet.privateKey); assert.equal(decryptedWallet.mnemonic.phrase, wallet.mnemonic.phrase, - "decrypted wallet menonic - " + wallet.privateKey); + "decrypted wallet mnemonic - " + wallet.privateKey); assert.equal(decryptedWallet.mnemonic.path, wallet.mnemonic.path, "decrypted wallet path - " + wallet.privateKey); return decryptedWallet.encrypt(password).then((encryptedWallet) => { @@ -129,7 +129,7 @@ describe('Test Transaction Signing and Parsing', function() { (function() { let unsignedTx = ethers.utils.serializeTransaction(transaction); assert.equal(unsignedTx, test.unsignedTransaction, - 'serializes undsigned transaction (legacy)'); + 'serializes unsigned transaction (legacy)'); // Legacy signed serialized transaction let signature = signDigest(ethers.utils.keccak256(unsignedTx)); diff --git a/packages/transactions/src.ts/index.ts b/packages/transactions/src.ts/index.ts index 8e954ad3eb..619ed19adf 100644 --- a/packages/transactions/src.ts/index.ts +++ b/packages/transactions/src.ts/index.ts @@ -165,7 +165,7 @@ export function serialize(transaction: UnsignedTransaction, signature?: Signatur export function parse(rawTransaction: BytesLike): Transaction { const transaction = RLP.decode(rawTransaction); if (transaction.length !== 9 && transaction.length !== 6) { - logger.throwArgumentError("invalid raw transaction", "rawTransactin", rawTransaction); + logger.throwArgumentError("invalid raw transaction", "rawTransaction", rawTransaction); } const tx: Transaction = { diff --git a/packages/wallet/src.ts/index.ts b/packages/wallet/src.ts/index.ts index c27ca59d2b..1322f064a1 100644 --- a/packages/wallet/src.ts/index.ts +++ b/packages/wallet/src.ts/index.ts @@ -48,7 +48,7 @@ export class Wallet extends Signer implements ExternallyOwnedAccount { defineReadOnly(this, "address", computeAddress(this.publicKey)); if (this.address !== getAddress(privateKey.address)) { - logger.throwArgumentError("privateKey/address mismatch", "privateKey", "[REDCACTED]"); + logger.throwArgumentError("privateKey/address mismatch", "privateKey", "[REDACTED]"); } if (hasMnemonic(privateKey)) { @@ -63,7 +63,7 @@ export class Wallet extends Signer implements ExternallyOwnedAccount { const mnemonic = this.mnemonic; const node = HDNode.fromMnemonic(mnemonic.phrase, null, mnemonic.locale).derivePath(mnemonic.path); if (computeAddress(node.privateKey) !== this.address) { - logger.throwArgumentError("mnemonic/address mismatch", "privateKey", "[REDCACTED]"); + logger.throwArgumentError("mnemonic/address mismatch", "privateKey", "[REDACTED]"); } } else { defineReadOnly(this, "_mnemonic", (): Mnemonic => null);