Added support for legacy ABI JSON fragments (#3932).

.github/workflows/generate-docs.yml

@@ -32,7 +32,7 @@ jobs:
         run: npm install --no-save 'https://github.com/ricmoo/flatworm.git#tsdocs'
 
       - name: Build Documentation
-        run: node node_modules/flatworm/lib/test-api-index ./docs.wrm/config.js
+        run: node node_modules/flatworm/lib/cli-test ./docs.wrm/config.js
 
       - name: Upload documentation to to docs.ethers.org
         uses: ethers-io/sync-s3-action@main

.github/workflows/test-ci.yml

@@ -32,6 +32,9 @@ jobs:
         with:
           node-version: ${{ matrix.node-version }}
 
+      - name: Install and run Geth
+        uses: ethers-io/run-geth-action@main
+
       - name: Checkout repository
         uses: actions/checkout@v2
 
@@ -63,6 +66,9 @@ jobs:
         with:
           node-version: 18.x
 
+      - name: Install and run Geth
+        uses: ethers-io/run-geth-action@main
+        
       - name: Checkout repository
         uses: actions/checkout@v2
 

CHANGELOG.md

@@ -1,7 +1,68 @@
 Change Log
 ==========
 
-This change log is maintained by `src.ts/_admin/update-changelog.ts but may also be manually updated.`
+This change log is maintained by `src.ts/_admin/update-changelog.ts` but may also be manually updated.
+
+ethers/v6.2.3 (2023-03-27 21:22)
+--------------------------------
+
+  - Fixed events when emitted in WebSocketProvider ([#3767](https://github.com/ethers-io/ethers.js/issues/3767), [#3922](https://github.com/ethers-io/ethers.js/issues/3922); [ffaafc0](https://github.com/ethers-io/ethers.js/commit/ffaafc0ce1cf40d1d76d8d814c9c445057bf6989)).
+
+ethers/v6.2.2 (2023-03-24 00:49)
+--------------------------------
+
+  - Fixed FetchRequest when using credentials ([#3897](https://github.com/ethers-io/ethers.js/issues/3897); [88e8124](https://github.com/ethers-io/ethers.js/commit/88e8124c37d377628f9b8abdf140fc07ad06259f)).
+
+ethers/v6.2.1 (2023-03-23 17:33)
+--------------------------------
+
+  - Stall block polling bootstrap when the network is down ([#3924](https://github.com/ethers-io/ethers.js/issues/3924); [603d474](https://github.com/ethers-io/ethers.js/commit/603d47496e2b667c15b72f315261d6e299381848)).
+
+ethers/v6.2.0 (2023-03-20 15:53)
+--------------------------------
+
+  - Added extra details in the error info field for RPC errors ([30ffa78](https://github.com/ethers-io/ethers.js/commit/30ffa78d1441fa033677fa09237fc135a314f373)).
+  - Remove Ankr as a deafult for now as the provided API key is failing ([6e01e54](https://github.com/ethers-io/ethers.js/commit/6e01e5448f4a3e2d30288d4c8447db295c3a2e7a)).
+  - Fixed deferred filters after unsafe-eval changes ([#3749](https://github.com/ethers-io/ethers.js/issues/3749), [#3763](https://github.com/ethers-io/ethers.js/issues/3763); [2e3802a](https://github.com/ethers-io/ethers.js/commit/2e3802a83b8ad2f5a6269d79fbd1c83c9f2d1047)).
+  - Remove use of Function sub-class to address unsafe-eval issues ([#3749](https://github.com/ethers-io/ethers.js/issues/3749), [#3763](https://github.com/ethers-io/ethers.js/issues/3763); [7d3af51](https://github.com/ethers-io/ethers.js/commit/7d3af512c75b4c24027ec2daef1e9f4c1064194a)).
+  - Added verifyTypedData utility (reported on Farcaster) ([f06a445](https://github.com/ethers-io/ethers.js/commit/f06a445247f3b294f9fc805cc8fe0752accb8edc)).
+  - Removed stray logging in IpcProvider ([#3908](https://github.com/ethers-io/ethers.js/issues/3908), [#3909](https://github.com/ethers-io/ethers.js/issues/3909); [e11d4c1](https://github.com/ethers-io/ethers.js/commit/e11d4c1c20cc5b6fd5803cf9636c4f5bc082dab7)).
+  - Fixed legacy serialization for implicit chainId transactions ([#3898](https://github.com/ethers-io/ethers.js/issues/3898), [#3899](https://github.com/ethers-io/ethers.js/issues/3899); [fcf6c8f](https://github.com/ethers-io/ethers.js/commit/fcf6c8fcee95ec412aaafba8ec84d5049b077a4e)).
+  - Fix Webpack issue (reported on discord) ([3ad4273](https://github.com/ethers-io/ethers.js/commit/3ad4273b8b714bff344ccbfb1eb71ed8a8b7cfa4)).
+  - Fix some bundlers which cannot handle recursive pkg.exports ([#3848](https://github.com/ethers-io/ethers.js/issues/3848); [6315e78](https://github.com/ethers-io/ethers.js/commit/6315e78ea32147653b72ca06f6800f3e2df6ffbf)).
+  - Fixed typo in signature.s error ([#3891](https://github.com/ethers-io/ethers.js/issues/3891); [47ef3eb](https://github.com/ethers-io/ethers.js/commit/47ef3ebde37bfa0c015c258c3d8a6800d751e147)).
+  - Fixed stray unreachable code ([#3890](https://github.com/ethers-io/ethers.js/issues/3890); [c220fe2](https://github.com/ethers-io/ethers.js/commit/c220fe2ea747ccc80cd3c4020e0278e3daf3c4fc)).
+  - Move all wrapping to proper _wrap functions ([#3818](https://github.com/ethers-io/ethers.js/issues/3818); [02a0aad](https://github.com/ethers-io/ethers.js/commit/02a0aad61212c35e8d2723a8ae589989b97dae3e)).
+
+ethers/v6.1.0 (2023-03-07 02:10)
+--------------------------------
+
+  - Fixed ethers imported in web workers ([#3856](https://github.com/ethers-io/ethers.js/issues/3856); [5f2678f](https://github.com/ethers-io/ethers.js/commit/5f2678fb059d643638b9cc1dc59cbfc61ce7a7b8)).
+  - Added Sepolia support ([#3863](https://github.com/ethers-io/ethers.js/issues/3863); [abeaa74](https://github.com/ethers-io/ethers.js/commit/abeaa74da04fbe25e837a2ffa7d1e9c1257a5da5)).
+  - Added missing exports ([#3734](https://github.com/ethers-io/ethers.js/issues/3734); [06aa303](https://github.com/ethers-io/ethers.js/commit/06aa30363f88144db672376d39012d7fe3f86c33)).
+  - Allow null values for TypedData domain ([#3623](https://github.com/ethers-io/ethers.js/issues/3623); [a32af3a](https://github.com/ethers-io/ethers.js/commit/a32af3adc104c4b07a45097a4a3725a4ce9e0be6)).
+  - Added listAccounts to JsonRpcProvider ([#3778](https://github.com/ethers-io/ethers.js/issues/3778); [287d94f](https://github.com/ethers-io/ethers.js/commit/287d94fc454d03f1b3086ea98745131cdf40129a)).
+  - Allow BigInt for blockTag ([#3780](https://github.com/ethers-io/ethers.js/issues/3780); [fe1f04c](https://github.com/ethers-io/ethers.js/commit/fe1f04c6e5fb4254a100f492d7dcbdc3cf19a446)).
+  - Fixed typo in error messages ([#3822](https://github.com/ethers-io/ethers.js/issues/3822), [#3824](https://github.com/ethers-io/ethers.js/issues/3824); [f1a810d](https://github.com/ethers-io/ethers.js/commit/f1a810dcb56df54b1e1567f2a59c73500619472f)).
+  - Re-adding definition files to require exports ([#3703](https://github.com/ethers-io/ethers.js/issues/3703); [76fab92](https://github.com/ethers-io/ethers.js/commit/76fab923da33e71e6bb751bb0b5e3ba3faa27ab2)).
+
+ethers/v6.0.8 (2023-02-23 06:30)
+--------------------------------
+
+  - Fix matic-mumbai network and include aliases to legacy names ([#3811](https://github.com/ethers-io/ethers.js/issues/3811); [20bbd12](https://github.com/ethers-io/ethers.js/commit/20bbd1281911d31b360f6f5032251c9257943541)).
+  - Fixed getSigner bug ([#3821](https://github.com/ethers-io/ethers.js/issues/3821); [388edf6](https://github.com/ethers-io/ethers.js/commit/388edf6abc168f89f1ca609e9e5b025dc9205add)).
+
+ethers/v6.0.7 (2023-02-23 01:41)
+--------------------------------
+
+  - Fixed getContentHash ([#3819](https://github.com/ethers-io/ethers.js/issues/3819); [b993f7c](https://github.com/ethers-io/ethers.js/commit/b993f7c3b6c0e135c460c8b8dc5943215628231a)).
+
+ethers/v6.0.6 (2023-02-22 21:53)
+--------------------------------
+
+  - Added chain parameters for Arbitrum and Optimism ([#3811](https://github.com/ethers-io/ethers.js/issues/3811); [77a7323](https://github.com/ethers-io/ethers.js/commit/77a7323119923e596f4def4f1bc90beae5447320)).
+  - Fix NonceManager race condition ([#3812](https://github.com/ethers-io/ethers.js/issues/3812), [#3813](https://github.com/ethers-io/ethers.js/issues/3813); [5a3c10a](https://github.com/ethers-io/ethers.js/commit/5a3c10a29c047609a50828adb620d88aa8cf0014)).
+  - Add UMD output to dist builds ([#3814](https://github.com/ethers-io/ethers.js/issues/3814); [f9eed4c](https://github.com/ethers-io/ethers.js/commit/f9eed4cdb190b06dd4ddaa2382c1de42e8e98de6)).
 
 ethers/v6.0.5 (2023-02-18 22:36)
 --------------------------------

dist/wordlists-extra.js

@@ -149,7 +149,7 @@ const u64 = {
 /**
  *  The current version of Ethers.
  */
-const version = "6.0.5";
+const version = "6.2.3";
 
 /**
  *  Property helper functions.
@@ -440,7 +440,7 @@ function replaceFunc(reason, offset, bytes, output, badCodepoint) {
  *  and accepts non-canonical (overlong) codepoints
  *
  *  **``"replace"``** - replace any illegal UTF-8 sequence with the
- *  UTF-8 replacement character (i.e. `\ufffd`) and accepts
+ *  UTF-8 replacement character (i.e. ``"\\ufffd"``) and accepts
  *  non-canonical (overlong) codepoints
  *
  *  @returns: Record<"error" | "ignore" | "replace", Utf8ErrorFunc>

docs.wrm/links/projects.txt

@@ -24,7 +24,7 @@ link-tally [Tally](https://tallyho.org)
 # Project-specific
 link-alchemy-signup [Alchemy Signup](https://dashboard.alchemyapi.io/signup?referral=55a35117-028e-4b7c-9e47-e275ad0acc6d)
 link-ankr-public [link-ankr-public](https://www.ankr.com/protocol/public/)
-link-ankr-premium [link-ankr-premium](https://www.ankr.com/protocol/plan/)
+link-ankr-signup [link-ankr-premium](https://www.ankr.com/protocol/plan/)
 link-etherscan-signup [Etherscan Signup](https://etherscan.io/apis)
 link-etherscan-ratelimit [link-etherscan-ratelimit](https://info.etherscan.com/api-return-errors/)
 link-infura-signup [INFURA Signup](https://infura.io/register)

docs.wrm/links/specs.txt

@@ -26,6 +26,7 @@ link-eip-1014 [EIP-1014](https://eips.ethereum.org/EIPS/eip-1014)
 link-eip-1193 [EIP-1193](https://eips.ethereum.org/EIPS/eip-1193)
 link-eip-1559 [EIP-1559](https://eips.ethereum.org/EIPS/eip-1559)
 link-eip-1577 [EIP-1577](https://eips.ethereum.org/EIPS/eip-1577)
+link-eip-2070 [EIP-2930](https://eips.ethereum.org/EIPS/eip-2070)
 link-eip-2098 [EIP-2098](https://eips.ethereum.org/EIPS/eip-2098)
 link-eip-2304 [EIP-2304](https://eips.ethereum.org/EIPS/eip-2304)
 link-eip-2718 [EIP-2718](https://eips.ethereum.org/EIPS/eip-2718)
@@ -41,6 +42,7 @@ link-mit [MIT License](https://en.m.wikipedia.org/wiki/MIT_License)
 link-namehash [namehash](https://docs.ens.domains/contract-api-reference/name-processing#hashing-names)
 link-rlp [Recursive-Length Prefix](https://ethereum.org/en/developers/docs/data-structures-and-encoding/rlp/)
 link-pbkdf2 [PBKDF2](https://en.wikipedia.org/wiki/PBKDF2)
+link-solc-abi [ABI Specification](https://docs.soliditylang.org/en/v0.8.19/abi-spec.html#formal-specification-of-the-encoding)
 link-solc-errors [Solidity Custom Errors](https://docs.soliditylang.org/en/v0.8.4/abi-spec.html#errors)
 link-solc-events [Solidity Events](https://docs.soliditylang.org/en/v0.8.4/abi-spec.html#events)
 link-solc-output [solc standard output](https://solidity.readthedocs.io/en/v0.6.0/using-the-compiler.html#output-description)

docs.wrm/migrating.wrm

@@ -214,6 +214,16 @@ _code: wrapping EIP-1193 providers  @lang<script>
   // v6:
   provider = new ethers.BrowserProvider(window.ethereum)
 
+Also, the method for braodcasting transactions to the network has
+changed:
+
+_code: broadcasting transactions  @lang<script>
+  // v5
+  provider.sendTransaction(signedTx)
+
+  // v6
+  provider.broadcastTransaction(signedTx)
+
 
 _subsection: Signatures  @<migrate-signatures>
 
@@ -236,7 +246,7 @@ The transaction helpers present in v5 were all wrapped into a
 [[Transaction]] class, which can handle any supported transaction
 format to be further processed
 
-_code: parasing transactions  @lang<script>
+_code: parsing transactions  @lang<script>
 
   // v5
   tx = parseTransaction(txBytes)
@@ -295,6 +305,37 @@ _code: defaultAbiCoder  @lang<script>
   // instance is returned.
   coder = AbiCoder.defaultAbiCoder()
 
+_code: fetching content  @lang<script>
+  // v5, with a body and no weird things
+  data = await ethers.utils.fetchJson(url, json, processFunc)
+
+  // v5 with Connection overrides
+  req = {
+      url, user: "username", password: "password"
+      // etc. properties have FetchRequest equivalents
+  };
+  data = await ethers.utils.detchJson(req, json, processFunc)
+
+  // v6
+  req = new ethers.FetchRequest(url)
+
+  // set a body; optional
+  req.body = json
+
+  // set credentials; optional
+  req.setCredentials("username", "password")
+
+  // set a processFunc; optional
+  req.processFunc = processFunc
+
+  // send the request!
+  resp = await req.send()
+
+  // Get the response body; depending on desired format
+  data = resp.body        // Uint8Array
+  data = resp.bodyText    // Utf8String; throws if invalid
+  data = resp.bodyJson    // Object; throws if invalid
+
 _code: hex conversion  @lang<script>
   // v5
   hex = ethers.utils.hexValue(value)

lib.commonjs/_tests/blockchain-data.d.ts

@@ -0,0 +1,84 @@
+export type TestBlockchainNetwork = "mainnet" | "goerli";
+export interface TestBlockchainAddress {
+    test: string;
+    address: string;
+    code?: string;
+    nonce?: number;
+    name?: string;
+    balance?: bigint;
+    storage?: Record<string, string>;
+}
+export interface TestBlockchainBlock {
+    test: string;
+    hash: string;
+    parentHash: string;
+    number: number;
+    timestamp: number;
+    nonce: string;
+    difficulty: bigint;
+    gasLimit: bigint;
+    gasUsed: bigint;
+    miner: string;
+    extraData: string;
+    transactions: Array<string>;
+    baseFeePerGas?: bigint;
+}
+export interface TestBlockchainTransaction {
+    test: string;
+    hash: string;
+    blockHash: string;
+    blockNumber: number;
+    type: number;
+    from: string;
+    gasPrice: bigint;
+    gasLimit: bigint;
+    to: string;
+    value: bigint;
+    nonce: number;
+    data: string;
+    signature: {
+        r: string;
+        s: string;
+        yParity: 0 | 1;
+        v: number;
+        networkV: null | bigint;
+    };
+    creates: null | string;
+    chainId: bigint;
+    accessList?: Array<Record<string, Array<string>>>;
+    maxPriorityFeePerGas?: bigint;
+    maxFeePerGas?: bigint;
+}
+export interface TestBlockchainReceipt {
+    test: string;
+    blockHash: string;
+    blockNumber: number;
+    type: number;
+    contractAddress: null | string;
+    cumulativeGasUsed: bigint;
+    from: string;
+    gasUsed: bigint;
+    gasPrice: bigint;
+    logs: Array<{
+        address: string;
+        blockHash: string;
+        blockNumber: number;
+        data: string;
+        index: number;
+        topics: Array<string>;
+        transactionHash: string;
+        transactionIndex: number;
+    }>;
+    logsBloom: string;
+    root: null | string;
+    status: null | number;
+    to: string;
+    hash: string;
+    index: number;
+}
+export declare const testAddress: Record<TestBlockchainNetwork, Array<TestBlockchainAddress>>;
+export declare const testBlock: Record<TestBlockchainNetwork, Array<TestBlockchainBlock>>;
+export declare const testTransaction: Record<TestBlockchainNetwork, Array<TestBlockchainTransaction>>;
+export declare const testReceipt: Record<TestBlockchainNetwork, Array<TestBlockchainReceipt>>;
+export declare const networkNames: Array<TestBlockchainNetwork>;
+export declare function networkFeatureAtBlock(feature: string, block: number): boolean;

lib.commonjs/_tests/create-provider.d.ts

@@ -0,0 +1,7 @@
+import type { AbstractProvider } from "../index.js";
+export declare function setupProviders(): void;
+export declare const providerNames: readonly string[];
+export declare function getProviderNetworks(provider: string): Array<string>;
+export declare function getProvider(provider: string, network: string): null | AbstractProvider;
+export declare function checkProvider(provider: string, network: string): boolean;
+export declare function connect(network: string): AbstractProvider;

lib.commonjs/_tests/create-provider.js

@@ -13,13 +13,15 @@ const ProviderCreators = [
             return new index_js_1.AlchemyProvider(network, "YrPw6SWb20vJDRFkhWq8aKnTQ8JRNRHM");
         }
     },
+    /*
     {
         name: "AnkrProvider",
-        networks: ethNetworks.concat(["matic", "arbitrum"]),
-        create: function (network) {
-            return new index_js_1.AnkrProvider(network);
+        networks: ethNetworks.concat([ "matic", "arbitrum" ]),
+        create: function(network: string) {
+            return new AnkrProvider(network);
         }
     },
+    */
     /*
     {
         name: "CloudflareProvider",

lib.commonjs/_tests/create-provider.js.map

@@ -1 +1 @@
-{"version":3,"file":"create-provider.js","sourceRoot":"","sources":["../../src.ts/_tests/create-provider.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"create-provider.js","sourceRoot":"","sources":["../../src.ts/_tests/create-provider.ts"],"names":[],"mappings":";;;AAAA,0CAWqB;AAQpB,CAAC;AAEF,MAAM,WAAW,GAAG,CAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAE,CAAC;AACvD,gDAAgD;AAEhD,MAAM,gBAAgB,GAA2B;IAC7C;QACI,IAAI,EAAE,iBAAiB;QACvB,QAAQ,EAAE,WAAW;QACrB,MAAM,EAAE,UAAS,OAAe;YAC5B,OAAO,IAAI,0BAAe,CAAC,OAAO,EAAE,kCAAkC,CAAC,CAAC;QAC5E,CAAC;KACJ;IACD;;;;;;;;MAQE;IACF;;;;;;;;MAQE;IACF;QACI,IAAI,EAAE,mBAAmB;QACzB,QAAQ,EAAE,WAAW;QACrB,MAAM,EAAE,UAAS,OAAe;YAC5B,OAAO,IAAI,4BAAiB,CAAC,OAAO,EAAE,oCAAoC,CAAC,CAAC;QAChF,CAAC;KACJ;IACD;QACI,IAAI,EAAE,gBAAgB;QACtB,QAAQ,EAAE,WAAW;QACrB,MAAM,EAAE,UAAS,OAAe;YAC5B,OAAO,IAAI,yBAAc,CAAC,OAAO,EAAE,kCAAkC,CAAC,CAAC;QAC3E,CAAC;KACJ;IACD;QACI,IAAI,EAAE,yBAAyB;QAC/B,QAAQ,EAAE,WAAW;QACrB,MAAM,EAAE,UAAS,OAAe;YAC5B,OAAO,yBAAc,CAAC,oBAAoB,CAAC,OAAO,EAAE,kCAAkC,CAAC,CAAC;QAC5F,CAAC;KACJ;IACD;QACI,IAAI,EAAE,gBAAgB;QACtB,QAAQ,EAAE,WAAW;QACrB,MAAM,EAAE,UAAS,OAAe;YAC5B,OAAO,IAAI,yBAAc,CAAC,OAAO,CAAC,CAAC;QACvC,CAAC;KACJ;IACD;QACI,IAAI,EAAE,mBAAmB;QACzB,QAAQ,EAAE,WAAW;QACrB,MAAM,EAAE,UAAS,OAAe;YAC5B,OAAO,IAAI,4BAAiB,CAAC,OAAO,CAAC,CAAC;QAC1C,CAAC;KACJ;IACD;QACI,IAAI,EAAE,kBAAkB;QACxB,QAAQ,EAAE,WAAW;QACrB,MAAM,EAAE,UAAS,OAAe;YAC5B,MAAM,SAAS,GAA4B,EAAE,CAAC;YAC9C,KAAK,MAAM,YAAY,IAAI,CAAE,iBAAiB,EAAE,cAAc,EAAE,mBAAmB,EAAE,gBAAgB,CAAE,EAAE;gBACrG,MAAM,QAAQ,GAAG,WAAW,CAAC,YAAY,EAAE,OAAO,CAAC,CAAC;gBACpD,IAAI,QAAQ,EAAE;oBAAE,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;iBAAE;aAC9C;YACD,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;gBAAE,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;aAAE;YACvE,OAAO,IAAI,2BAAgB,CAAC,SAAS,CAAC,CAAC;QAC3C,CAAC;KACJ;CACJ,CAAC;AAEF,IAAI,KAAK,GAAG,KAAK,CAAC;AAClB,MAAM,OAAO,GAAsB,EAAG,CAAC;AACvC,SAAgB,cAAc;IAC1B,KAAK,CAAC;QACF,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE;YAAE,IAAI,EAAE,CAAC;SAAE;IAC3C,CAAC,CAAC,CAAC;IACH,KAAK,GAAG,IAAI,CAAC;AACjB,CAAC;AALD,wCAKC;AAEY,QAAA,aAAa,GAAG,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAElF,SAAS,UAAU,CAAC,QAAgB;IAChC,MAAM,QAAQ,GAAG,gBAAgB,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC;IACvE,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;QAAE,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;KAAE;IAClD,OAAO,IAAI,CAAC;AAChB,CAAC;AAED,SAAgB,mBAAmB,CAAC,QAAgB;IAChD,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;IACrC,IAAI,OAAO,EAAE;QAAE,OAAO,OAAO,CAAC,QAAQ,CAAC;KAAE;IACzC,OAAO,EAAG,CAAC;AACf,CAAC;AAJD,kDAIC;AAED,SAAgB,WAAW,CAAC,QAAgB,EAAE,OAAe;IACzD,IAAI,KAAK,IAAI,KAAK,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;KAAE;IAEpF,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;IACrC,IAAI;QACA,IAAI,OAAO,EAAE;YACT,MAAM,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;YACzC,IAAI,QAAQ,EAAE;gBACV,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;aAC/C;YACD,OAAO,QAAQ,CAAC;SACnB;KACJ;IAAC,OAAO,KAAK,EAAE;QACZ,IAAI,CAAC,IAAA,kBAAO,EAAC,KAAK,EAAE,kBAAkB,CAAC,EAAE;YAAE,MAAM,KAAK,CAAC;SAAE;KAC5D;IACD,OAAO,IAAI,CAAC;AAChB,CAAC;AAhBD,kCAgBC;AAED,SAAgB,aAAa,CAAC,QAAgB,EAAE,OAAe;IAC3D,MAAM,OAAO,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;IACrC,OAAO,CAAC,OAAO,IAAI,IAAI,CAAC,CAAC;AAC7B,CAAC;AAHD,sCAGC;AAED,SAAgB,OAAO,CAAC,OAAe;IACnC,MAAM,QAAQ,GAAG,WAAW,CAAC,gBAAgB,EAAE,OAAO,CAAC,CAAC;IACxD,IAAI,QAAQ,IAAI,IAAI,EAAE;QAAE,MAAM,IAAI,KAAK,CAAC,wBAAyB,OAAQ,EAAE,CAAC,CAAC;KAAE;IAC/E,OAAO,QAAQ,CAAC;AACpB,CAAC;AAJD,0BAIC"}

lib.commonjs/_tests/test-abi.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-address.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-contract-integ.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-contract-integ.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const index_js_1 = require("../index.js");
+describe("Tests contract integration", function () {
+    const provider = new index_js_1.ethers.JsonRpcProvider("http:/\/127.0.0.1:8545");
+    const abi = [
+        "constructor(address owner, uint maxSupply)",
+        "function mint(address target) returns (bool minted)",
+        "function totalSupply() view returns (uint supply)",
+        "function balanceOf(address target) view returns (uint balance)",
+        "event Minted(address target)"
+    ];
+    let address = null;
+    it("deploys a contract", async function () {
+        this.timeout(10000);
+        const bytecode = "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";
+        const signer = await provider.getSigner(0);
+        const factory = new index_js_1.ethers.ContractFactory(abi, bytecode, signer);
+        const contract = await factory.deploy(signer, 100);
+        address = await contract.getAddress();
+        await contract.waitForDeployment();
+        const deployed = await provider.getCode(address);
+        assert_1.default.ok(deployed != "0x", "has bytescode");
+    });
+    it("runs contract operations", async function () {
+        this.timeout(10000);
+        assert_1.default.ok(address != null);
+        const signer = await provider.getSigner(0);
+        const CustomContract = index_js_1.ethers.BaseContract.buildClass(abi);
+        const contract = new CustomContract(address, signer); //ethers.Contract.from<ContractAbi>(address, abi, signer);
+        // Test implicit staticCall (i.e. view/pure)
+        {
+            const supply0 = await contract.totalSupply();
+            assert_1.default.equal(supply0, BigInt(0), "initial supply 0; default");
+        }
+        // Test explicit staticCall
+        {
+            const supply0 = await contract.totalSupply.staticCall();
+            assert_1.default.equal(supply0, BigInt(0), "initial supply 0; staticCall");
+        }
+        // Test staticCallResult (positional and named)
+        {
+            const supply0 = await contract.totalSupply.staticCallResult();
+            assert_1.default.equal(supply0[0], BigInt(0), "initial supply 0; staticCallResult");
+            assert_1.default.equal(supply0.supply, BigInt(0), "initial supply 0; staticCallResult");
+        }
+        // Test populateTransaction
+        const txInfo = await contract.mint.populateTransaction(signer);
+        assert_1.default.equal(txInfo.to, address, "populateTransaction.to");
+        const txInfoData = index_js_1.ethers.hexlify(index_js_1.ethers.concat([
+            "0x6a627842",
+            index_js_1.ethers.zeroPadValue(await signer.getAddress(), 32)
+        ]));
+        assert_1.default.equal(txInfo.data, txInfoData, "populateTransaction.data");
+        // Test minting (default)
+        const tx = await contract.mint(signer);
+        const receipt = await tx.wait();
+        assert_1.default.ok(receipt, "receipt");
+        // Check the receipt has parsed the events
+        assert_1.default.equal(receipt.logs.length, 1, "logs.length");
+        assert_1.default.ok(receipt instanceof index_js_1.ethers.ContractTransactionReceipt, "receipt typeof");
+        assert_1.default.ok(receipt.logs[0] instanceof index_js_1.ethers.EventLog, "receipt.log typeof");
+        assert_1.default.equal(receipt.logs[0].fragment && receipt.logs[0].fragment.name, "Minted", "logs[0].fragment.name");
+        assert_1.default.equal(receipt.logs[0].args[0], await signer.getAddress(), "logs[0].args[0]");
+        assert_1.default.equal(receipt.logs[0].args.target, await signer.getAddress(), "logs[0].args.target");
+        // Check the state has been adjusted
+        assert_1.default.equal(await contract.totalSupply(), BigInt(1), "initial supply 1; default");
+        assert_1.default.equal(await contract.balanceOf(signer), BigInt(1), "balanceOf(signer)");
+        // Test minting (explicit)
+        const tx2 = await contract.mint.send(signer);
+        await tx2.wait();
+        // Check the state has been adjusted
+        assert_1.default.equal(await contract.totalSupply(), BigInt(2), "initial supply 2; default");
+    });
+});
+//# sourceMappingURL=test-contract-integ.js.map

lib.commonjs/_tests/test-contract-integ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test-contract-integ.js","sourceRoot":"","sources":["../../src.ts/_tests/test-contract-integ.ts"],"names":[],"mappings":"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"}

lib.commonjs/_tests/test-contract.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-crypto-algoswap.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-crypto.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-hash-typeddata.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-hash.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-providers-avatar.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-providers-ccip.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-providers-data.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-providers-errors.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-providers-errors.js

@@ -36,6 +36,7 @@ describe("Tests Provider Call Exception", function () {
                         (0, index_js_1.dataSlice)((0, index_js_1.id)("testPanic(uint256)"), 0, 4),
                         (0, index_js_1.zeroPadValue)((0, index_js_1.toBeArray)(code), 32)
                     ]);
+                    await (0, utils_js_1.stall)(1000);
                     const tx = { to: testAddr, data };
                     try {
                         const result = await (method === "call" ? provider.call(tx) : provider.estimateGas(tx));

lib.commonjs/_tests/test-providers-extra.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-providers-send.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-providers-wildcard.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-rlp.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-transaction.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-utils-maths.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-utils-misc.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-utils-units.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-utils-utf8.d.ts

@@ -0,0 +1,12 @@
+export type TestCaseBadString = {
+    name: string;
+    bytes: Uint8Array;
+    ignore: string;
+    replace: string;
+    error: string;
+};
+export type TestCaseCodePoints = {
+    name: string;
+    text: string;
+    codepoints: Array<number>;
+};

lib.commonjs/_tests/test-wallet-hd.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    class TextDecoder {
+        decode(data: Uint8Array): string;
+    }
+}
+export {};

lib.commonjs/_tests/test-wallet-json.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-wallet-mnemonic.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-wallet.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/test-wordlists.d.ts

@@ -0,0 +1 @@
+export {};

lib.commonjs/_tests/types.d.ts

@@ -0,0 +1,216 @@
+export type TestCaseAbiVerbose = {
+    type: "address" | "hexstring" | "number" | "string";
+    value: string;
+} | {
+    type: "boolean";
+    value: boolean;
+} | {
+    type: "array";
+    value: Array<TestCaseAbiVerbose>;
+} | {
+    type: "object";
+    value: Array<TestCaseAbiVerbose>;
+};
+export interface TestCaseAbi {
+    name: string;
+    type: string;
+    value: any;
+    verbose: TestCaseAbiVerbose;
+    bytecode: string;
+    encoded: string;
+}
+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;
+    }>;
+};
+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;
+}
+export interface TestCaseHash {
+    name: string;
+    data: string;
+    sha256: string;
+    sha512: string;
+    ripemd160: string;
+    keccak256: string;
+}
+export interface TestCaseNamehash {
+    name: string;
+    ensName: string;
+    error?: 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<string, Array<TestCaseTypedDataType>>;
+    data: any;
+    encoded: string;
+    digest: string;
+    privateKey?: string;
+    signature?: string;
+}
+export interface TestCaseSolidityHash {
+    name: string;
+    types: Array<string>;
+    keccak256: string;
+    ripemd160: string;
+    sha256: string;
+    values: Array<any>;
+}
+export interface TestCaseUnit {
+    name: string;
+    wei: string;
+    ethers: string;
+    ether_format: string;
+    kwei?: string;
+    mwei?: string;
+    gwei?: string;
+    szabo?: string;
+    finney?: string;
+    finney_format?: string;
+    szabo_format?: string;
+    gwei_format?: string;
+    mwei_format?: string;
+    kwei_format?: string;
+}
+export type NestedHexString = string | Array<string | NestedHexString>;
+export interface TestCaseRlp {
+    name: string;
+    encoded: string;
+    decoded: NestedHexString;
+}
+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<string>;
+    }>;
+    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;
+}
+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<TestCaseMnemonicNode>;
+}
+export interface TestCaseWallet {
+    name: string;
+    filename: string;
+    type: string;
+    address: string;
+    password: string;
+    content: string;
+}
+export interface TestCaseWordlist {
+    name: string;
+    filename: string;
+    locale: string;
+    content: string;
+}

lib.commonjs/_tests/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function loadTests<T>(tag: string): Array<T>;
+export declare function log(context: any, text: string): void;
+export declare function stall(duration: number): Promise<void>;
+export interface MochaRunnable {
+    timeout: (value: number) => void;
+    skip: () => void;
+}
+export declare function retryIt(name: string, func: (this: MochaRunnable) => Promise<void>): Promise<void>;

lib.commonjs/_version.d.ts

@@ -0,0 +1,4 @@
+/**
+ *  The current version of Ethers.
+ */
+export declare const version: string;

lib.commonjs/_version.js

@@ -5,5 +5,5 @@ exports.version = void 0;
 /**
  *  The current version of Ethers.
  */
-exports.version = "6.0.5";
+exports.version = "6.2.3";
 //# sourceMappingURL=_version.js.map

lib.commonjs/abi/abi-coder.d.ts

@@ -0,0 +1,58 @@
+/**
+ *  When sending values to or receiving values from a [[Contract]], the
+ *  data is generally encoded using the [ABI standard](link-solc-abi).
+ *
+ *  The AbiCoder provides a utility to encode values to ABI data and
+ *  decode values from ABI data.
+ *
+ *  Most of the time, developers should favour the [[Contract]] class,
+ *  which further abstracts a lot of the finer details of ABI data.
+ *
+ *  @_section api/abi/abi-coder:ABI Encoding
+ */
+import { Result } from "./coders/abstract-coder.js";
+import { ParamType } from "./fragments.js";
+import type { BytesLike, CallExceptionAction, CallExceptionError } from "../utils/index.js";
+/**
+  * About AbiCoder
+  */
+export declare class AbiCoder {
+    #private;
+    /**
+     *  Get the default values for the given %%types%%.
+     *
+     *  For example, a ``uint`` is by default ``0`` and ``bool``
+     *  is by default ``false``.
+     */
+    getDefaultValue(types: ReadonlyArray<string | ParamType>): Result;
+    /**
+     *  Encode the %%values%% as the %%types%% into ABI data.
+     *
+     *  @returns DataHexstring
+     */
+    encode(types: ReadonlyArray<string | ParamType>, values: ReadonlyArray<any>): string;
+    /**
+     *  Decode the ABI %%data%% as the %%types%% into values.
+     *
+     *  If %%loose%% decoding is enabled, then strict padding is
+     *  not enforced. Some older versions of Solidity incorrectly
+     *  padded event data emitted from ``external`` functions.
+     */
+    decode(types: ReadonlyArray<string | ParamType>, data: BytesLike, loose?: boolean): Result;
+    /**
+     *  Returns the shared singleton instance of a default [[AbiCoder]].
+     *
+     *  On the first call, the instance is created internally.
+     */
+    static defaultAbiCoder(): AbiCoder;
+    /**
+     *  Returns an ethers-compatible [[CallExceptionError]] Error for the given
+     *  result %%data%% for the [[CallExceptionAction]] %%action%% against
+     *  the Transaction %%tx%%.
+     */
+    static getBuiltinCallException(action: CallExceptionAction, tx: {
+        to?: null | string;
+        from?: null | string;
+        data?: string;
+    }, data: null | BytesLike): CallExceptionError;
+}

lib.commonjs/abi/abi-coder.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  *  When sending values to or receiving values from a [[Contract]], the
- *  data is generally encoded using the [ABI standard](solc-abi-standard).
+ *  data is generally encoded using the [ABI standard](link-solc-abi).
  *
  *  The AbiCoder provides a utility to encode values to ABI data and
  *  decode values from ABI data.

lib.commonjs/abi/bytes32.d.ts

@@ -0,0 +1,14 @@
+/**
+ *  About bytes32 strings...
+ *
+ *  @_docloc: api/utils:Bytes32 Strings
+ */
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Encodes %%text%% as a Bytes32 string.
+ */
+export declare function encodeBytes32String(text: string): string;
+/**
+ *  Encodes the Bytes32-encoded %%bytes%% into a string.
+ */
+export declare function decodeBytes32String(_bytes: BytesLike): string;

lib.commonjs/abi/coders/abstract-coder.d.ts

@@ -0,0 +1,116 @@
+import type { BigNumberish, BytesLike } from "../../utils/index.js";
+/**
+ * @_ignore:
+ */
+export declare const WordSize: number;
+/**
+ *  A [[Result]] is a sub-class of Array, which allows accessing any
+ *  of its values either positionally by its index or, if keys are
+ *  provided by its name.
+ *
+ *  @_docloc: api/abi
+ */
+export declare class Result extends Array<any> {
+    #private;
+    [K: string | number]: any;
+    /**
+     *  @private
+     */
+    constructor(...args: Array<any>);
+    /**
+     *  Returns the Result as a normal Array.
+     *
+     *  This will throw if there are any outstanding deferred
+     *  errors.
+     */
+    toArray(): Array<any>;
+    /**
+     *  Returns the Result as an Object with each name-value pair.
+     *
+     *  This will throw if any value is unnamed, or if there are
+     *  any outstanding deferred errors.
+     */
+    toObject(): Record<string, any>;
+    /**
+     *  @_ignore
+     */
+    slice(start?: number | undefined, end?: number | undefined): Result;
+    /**
+     *  @_ignore
+     */
+    filter(callback: (el: any, index: number, array: Result) => boolean, thisArg?: any): Result;
+    /**
+     *  Returns the value for %%name%%.
+     *
+     *  Since it is possible to have a key whose name conflicts with
+     *  a method on a [[Result]] or its superclass Array, or any
+     *  JavaScript keyword, this ensures all named values are still
+     *  accessible by name.
+     */
+    getValue(name: string): any;
+    /**
+     *  Creates a new [[Result]] for %%items%% with each entry
+     *  also accessible by its corresponding name in %%keys%%.
+     */
+    static fromItems(items: Array<any>, keys?: Array<null | string>): Result;
+}
+/**
+ *  Returns all errors found in a [[Result]].
+ *
+ *  Since certain errors encountered when creating a [[Result]] do
+ *  not impact the ability to continue parsing data, they are
+ *  deferred until they are actually accessed. Hence a faulty string
+ *  in an Event that is never used does not impact the program flow.
+ *
+ *  However, sometimes it may be useful to access, identify or
+ *  validate correctness of a [[Result]].
+ *
+ *  @_docloc api/abi
+ */
+export declare function checkResultErrors(result: Result): Array<{
+    path: Array<string | number>;
+    error: Error;
+}>;
+/**
+ *  @_ignore
+ */
+export declare abstract class Coder {
+    readonly name: string;
+    readonly type: string;
+    readonly localName: string;
+    readonly dynamic: boolean;
+    constructor(name: string, type: string, localName: string, dynamic: boolean);
+    _throwError(message: string, value: any): never;
+    abstract encode(writer: Writer, value: any): number;
+    abstract decode(reader: Reader): any;
+    abstract defaultValue(): any;
+}
+/**
+ *  @_ignore
+ */
+export declare class Writer {
+    #private;
+    constructor();
+    get data(): string;
+    get length(): number;
+    appendWriter(writer: Writer): number;
+    writeBytes(value: BytesLike): number;
+    writeValue(value: BigNumberish): number;
+    writeUpdatableValue(): (value: BigNumberish) => void;
+}
+/**
+ *  @_ignore
+ */
+export declare class Reader {
+    #private;
+    readonly allowLoose: boolean;
+    constructor(data: BytesLike, allowLoose?: boolean);
+    get data(): string;
+    get dataLength(): number;
+    get consumed(): number;
+    get bytes(): Uint8Array;
+    subReader(offset: number): Reader;
+    readBytes(length: number, loose?: boolean): Uint8Array;
+    readValue(): bigint;
+    readIndex(): number;
+}

lib.commonjs/abi/coders/address.d.ts

@@ -0,0 +1,12 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class AddressCoder extends Coder {
+    constructor(localName: string);
+    defaultValue(): string;
+    encode(writer: Writer, _value: string | Typed): number;
+    decode(reader: Reader): any;
+}

lib.commonjs/abi/coders/anonymous.d.ts

@@ -0,0 +1,14 @@
+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
+ *
+ *  @_ignore
+ */
+export declare class AnonymousCoder extends Coder {
+    private coder;
+    constructor(coder: Coder);
+    defaultValue(): any;
+    encode(writer: Writer, value: any): number;
+    decode(reader: Reader): any;
+}

lib.commonjs/abi/coders/array.d.ts

@@ -0,0 +1,24 @@
+import { Typed } from "../typed.js";
+import { Coder, Result, Writer } from "./abstract-coder.js";
+import type { Reader } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare function pack(writer: Writer, coders: ReadonlyArray<Coder>, values: Array<any> | {
+    [name: string]: any;
+}): number;
+/**
+ *  @_ignore
+ */
+export declare function unpack(reader: Reader, coders: ReadonlyArray<Coder>): Result;
+/**
+ *  @_ignore
+ */
+export declare class ArrayCoder extends Coder {
+    readonly coder: Coder;
+    readonly length: number;
+    constructor(coder: Coder, length: number, localName: string);
+    defaultValue(): Array<any>;
+    encode(writer: Writer, _value: Array<any> | Typed): number;
+    decode(reader: Reader): any;
+}

lib.commonjs/abi/coders/boolean.d.ts

@@ -0,0 +1,12 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class BooleanCoder extends Coder {
+    constructor(localName: string);
+    defaultValue(): boolean;
+    encode(writer: Writer, _value: boolean | Typed): number;
+    decode(reader: Reader): any;
+}

lib.commonjs/abi/coders/bytes.d.ts

@@ -0,0 +1,18 @@
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class DynamicBytesCoder extends Coder {
+    constructor(type: string, localName: string);
+    defaultValue(): string;
+    encode(writer: Writer, value: any): number;
+    decode(reader: Reader): any;
+}
+/**
+ *  @_ignore
+ */
+export declare class BytesCoder extends DynamicBytesCoder {
+    constructor(localName: string);
+    decode(reader: Reader): any;
+}

lib.commonjs/abi/coders/fixed-bytes.d.ts

@@ -0,0 +1,14 @@
+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";
+/**
+ *  @_ignore
+ */
+export declare class FixedBytesCoder extends Coder {
+    readonly size: number;
+    constructor(size: number, localName: string);
+    defaultValue(): string;
+    encode(writer: Writer, _value: BytesLike | Typed): number;
+    decode(reader: Reader): any;
+}

lib.commonjs/abi/coders/null.d.ts

@@ -0,0 +1,11 @@
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class NullCoder extends Coder {
+    constructor(localName: string);
+    defaultValue(): null;
+    encode(writer: Writer, value: any): number;
+    decode(reader: Reader): any;
+}

lib.commonjs/abi/coders/number.d.ts

@@ -0,0 +1,15 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { BigNumberish } from "../../utils/index.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class NumberCoder extends Coder {
+    readonly size: number;
+    readonly signed: boolean;
+    constructor(size: number, signed: boolean, localName: string);
+    defaultValue(): number;
+    encode(writer: Writer, _value: BigNumberish | Typed): number;
+    decode(reader: Reader): any;
+}

lib.commonjs/abi/coders/string.d.ts

@@ -0,0 +1,12 @@
+import { Typed } from "../typed.js";
+import { DynamicBytesCoder } from "./bytes.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class StringCoder extends DynamicBytesCoder {
+    constructor(localName: string);
+    defaultValue(): string;
+    encode(writer: Writer, _value: string | Typed): number;
+    decode(reader: Reader): any;
+}

lib.commonjs/abi/coders/tuple.d.ts

@@ -0,0 +1,15 @@
+import { Typed } from "../typed.js";
+import { Coder } from "./abstract-coder.js";
+import type { Reader, Writer } from "./abstract-coder.js";
+/**
+ *  @_ignore
+ */
+export declare class TupleCoder extends Coder {
+    readonly coders: ReadonlyArray<Coder>;
+    constructor(coders: Array<Coder>, localName: string);
+    defaultValue(): any;
+    encode(writer: Writer, _value: Array<any> | {
+        [name: string]: any;
+    } | Typed): number;
+    decode(reader: Reader): any;
+}

lib.commonjs/abi/fragments.d.ts

@@ -0,0 +1,371 @@
+/**
+ *  About frgaments...
+ *
+ *  @_subsection api/abi/abi-coder:Fragments  [about-fragments]
+ */
+/**
+ *  A type description in a JSON API.
+ */
+export interface JsonFragmentType {
+    /**
+     *  The parameter name.
+     */
+    readonly name?: string;
+    /**
+     *  If the parameter is indexed.
+     */
+    readonly indexed?: boolean;
+    /**
+     *  The type of the parameter.
+     */
+    readonly type?: string;
+    /**
+     *  The internal Solidity type.
+     */
+    readonly internalType?: string;
+    /**
+     *  The components for a tuple.
+     */
+    readonly components?: ReadonlyArray<JsonFragmentType>;
+}
+/**
+ *  A fragment for a method, event or error in a JSON API.
+ */
+export interface JsonFragment {
+    /**
+     *  The name of the error, event, function, etc.
+     */
+    readonly name?: string;
+    /**
+     *  The type of the fragment (e.g. ``event``, ``"function"``, etc.)
+     */
+    readonly type?: string;
+    /**
+     *  If the event is anonymous.
+     */
+    readonly anonymous?: boolean;
+    /**
+     *  If the function is payable.
+     */
+    readonly payable?: boolean;
+    /**
+     *  If the function is constant.
+     */
+    readonly constant?: boolean;
+    /**
+     *  The mutability state of the function.
+     */
+    readonly stateMutability?: string;
+    /**
+     *  The input parameters.
+     */
+    readonly inputs?: ReadonlyArray<JsonFragmentType>;
+    /**
+     *  The output parameters.
+     */
+    readonly outputs?: ReadonlyArray<JsonFragmentType>;
+    /**
+     *  The gas limit to use when sending a transaction for this function.
+     */
+    readonly gas?: string;
+}
+/**
+ *  The format to serialize the output as.
+ */
+export type FormatType = "sighash" | "minimal" | "full" | "json";
+/**
+ *  When [walking](ParamType-walk) a [[ParamType]], this is called
+ *  on each component.
+ */
+export type ParamTypeWalkFunc = (type: string, value: any) => any;
+/**
+ *  When [walking asynchronously](ParamType-walkAsync) a [[ParamType]],
+ *  this is called on each component.
+ */
+export type ParamTypeWalkAsyncFunc = (type: string, value: any) => any | Promise<any>;
+/**
+ *  Each input and output of a [[Fragment]] is an Array of **PAramType**.
+ */
+export declare class ParamType {
+    #private;
+    /**
+     *  The local name of the parameter (or ``""`` 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;
+    /**
+     *  True if the parameters is indexed.
+     *
+     *  For non-indexable types this is ``null``.
+     */
+    readonly indexed: null | boolean;
+    /**
+     *  The components for the tuple.
+     *
+     *  For non-tuple types this is ``null``.
+     */
+    readonly components: null | ReadonlyArray<ParamType>;
+    /**
+     *  The array length, or ``-1`` for dynamic-lengthed arrays.
+     *
+     *  For non-array types this is ``null``.
+     */
+    readonly arrayLength: null | number;
+    /**
+     *  The type of each child in the array.
+     *
+     *  For non-array types this is ``null``.
+     */
+    readonly arrayChildren: null | ParamType;
+    /**
+     *  @private
+     */
+    constructor(guard: any, name: string, type: string, baseType: string, indexed: null | boolean, components: null | ReadonlyArray<ParamType>, arrayLength: null | number, arrayChildren: null | ParamType);
+    /**
+     *  Return a string representation of this type.
+     *
+     *  For example,
+     *
+     *  ``sighash" => "(uint256,address)"``
+     *
+     *  ``"minimal" => "tuple(uint256,address) indexed"``
+     *
+     *  ``"full" => "tuple(uint256 foo, address bar) indexed baz"``
+     */
+    format(format?: FormatType): string;
+    /**
+     *  Returns true if %%this%% is an Array type.
+     *
+     *  This provides a type gaurd ensuring that [[arrayChildren]]
+     *  and [[arrayLength]] are non-null.
+     */
+    isArray(): this is (ParamType & {
+        arrayChildren: ParamType;
+        arrayLength: number;
+    });
+    /**
+     *  Returns true if %%this%% is a Tuple type.
+     *
+     *  This provides a type gaurd ensuring that [[components]]
+     *  is non-null.
+     */
+    isTuple(): this is (ParamType & {
+        components: ReadonlyArray<ParamType>;
+    });
+    /**
+     *  Returns true if %%this%% is an Indexable type.
+     *
+     *  This provides a type gaurd ensuring that [[indexed]]
+     *  is non-null.
+     */
+    isIndexable(): this is (ParamType & {
+        indexed: boolean;
+    });
+    /**
+     *  Walks the **ParamType** with %%value%%, calling %%process%%
+     *  on each type, destructing the %%value%% recursively.
+     */
+    walk(value: any, process: ParamTypeWalkFunc): any;
+    /**
+     *  Walks the **ParamType** with %%value%%, asynchronously calling
+     *  %%process%% on each type, destructing the %%value%% recursively.
+     *
+     *  This can be used to resolve ENS naes by walking and resolving each
+     *  ``"address"`` type.
+     */
+    walkAsync(value: any, process: ParamTypeWalkAsyncFunc): Promise<any>;
+    /**
+     *  Creates a new **ParamType** for %%obj%%.
+     *
+     *  If %%allowIndexed%% then the ``indexed`` keyword is permitted,
+     *  otherwise the ``indexed`` keyword will throw an error.
+     */
+    static from(obj: any, allowIndexed?: boolean): ParamType;
+    /**
+     *  Returns true if %%value%% is a **ParamType**.
+     */
+    static isParamType(value: any): value is ParamType;
+}
+/**
+ *  The type of a [[Fragment]].
+ */
+export type FragmentType = "constructor" | "error" | "event" | "fallback" | "function" | "struct";
+/**
+ *  An abstract class to represent An individual fragment from a parse ABI.
+ */
+export declare abstract class Fragment {
+    /**
+     *  The type of the fragment.
+     */
+    readonly type: FragmentType;
+    /**
+     *  The inputs for the fragment.
+     */
+    readonly inputs: ReadonlyArray<ParamType>;
+    /**
+     *  @private
+     */
+    constructor(guard: any, type: FragmentType, inputs: ReadonlyArray<ParamType>);
+    /**
+     *  Returns a string representation of this fragment.
+     */
+    abstract format(format?: FormatType): string;
+    /**
+     *  Creates a new **Fragment** for %%obj%%, wich can be any supported
+     *  ABI frgament type.
+     */
+    static from(obj: any): Fragment;
+    /**
+     *  Returns true if %%value%% is a [[ConstructorFragment]].
+     */
+    static isConstructor(value: any): value is ConstructorFragment;
+    /**
+     *  Returns true if %%value%% is an [[ErrorFragment]].
+     */
+    static isError(value: any): value is ErrorFragment;
+    /**
+     *  Returns true if %%value%% is an [[EventFragment]].
+     */
+    static isEvent(value: any): value is EventFragment;
+    /**
+     *  Returns true if %%value%% is a [[FunctionFragment]].
+     */
+    static isFunction(value: any): value is FunctionFragment;
+    /**
+     *  Returns true if %%value%% is a [[StructFragment]].
+     */
+    static isStruct(value: any): value is StructFragment;
+}
+/**
+ *  An abstract class to represent An individual fragment
+ *  which has a name from a parse ABI.
+ */
+export declare abstract class NamedFragment extends Fragment {
+    /**
+     *  The name of the fragment.
+     */
+    readonly name: string;
+    /**
+     *  @private
+     */
+    constructor(guard: any, type: FragmentType, name: string, inputs: ReadonlyArray<ParamType>);
+}
+/**
+ *  A Fragment which represents a //Custom Error//.
+ */
+export declare class ErrorFragment extends NamedFragment {
+    /**
+     *  @private
+     */
+    constructor(guard: any, name: string, inputs: ReadonlyArray<ParamType>);
+    /**
+     *  The Custom Error selector.
+     */
+    get selector(): string;
+    format(format?: FormatType): string;
+    static from(obj: any): ErrorFragment;
+    static isFragment(value: any): value is ErrorFragment;
+}
+/**
+ *  A Fragment which represents an Event.
+ */
+export declare class EventFragment extends NamedFragment {
+    readonly anonymous: boolean;
+    /**
+     *  @private
+     */
+    constructor(guard: any, name: string, inputs: ReadonlyArray<ParamType>, anonymous: boolean);
+    /**
+     *  The Event topic hash.
+     */
+    get topicHash(): string;
+    format(format?: FormatType): string;
+    static getTopicHash(name: string, params?: Array<any>): string;
+    static from(obj: any): EventFragment;
+    static isFragment(value: any): value is EventFragment;
+}
+/**
+ *  A Fragment which represents a constructor.
+ */
+export declare class ConstructorFragment extends Fragment {
+    readonly payable: boolean;
+    readonly gas: null | bigint;
+    /**
+     *  @private
+     */
+    constructor(guard: any, type: FragmentType, inputs: ReadonlyArray<ParamType>, payable: boolean, gas: null | bigint);
+    format(format?: FormatType): string;
+    static from(obj: any): ConstructorFragment;
+    static isFragment(value: any): value is ConstructorFragment;
+}
+/**
+ *  A Fragment which represents a method.
+ */
+export declare class FallbackFragment extends Fragment {
+    /**
+     *  If the function can be sent value during invocation.
+     */
+    readonly payable: boolean;
+    constructor(guard: any, inputs: ReadonlyArray<ParamType>, payable: boolean);
+    format(format?: FormatType): string;
+    static from(obj: any): FallbackFragment;
+    static isFragment(value: any): value is FallbackFragment;
+}
+/**
+ *  A Fragment which represents a method.
+ */
+export declare class FunctionFragment extends NamedFragment {
+    /**
+     *  If the function is constant (e.g. ``pure`` or ``view`` functions).
+     */
+    readonly constant: boolean;
+    /**
+     *  The returned types for the result of calling this function.
+     */
+    readonly outputs: ReadonlyArray<ParamType>;
+    /**
+     *  The state mutability (e.g. ``payable``, ``nonpayable``, ``view``
+     *  or ``pure``)
+     */
+    readonly stateMutability: "payable" | "nonpayable" | "view" | "pure";
+    /**
+     *  If the function can be sent value during invocation.
+     */
+    readonly payable: boolean;
+    /**
+     *  The amount of gas to send when calling this function
+     */
+    readonly gas: null | bigint;
+    /**
+     *  @private
+     */
+    constructor(guard: any, name: string, stateMutability: "payable" | "nonpayable" | "view" | "pure", inputs: ReadonlyArray<ParamType>, outputs: ReadonlyArray<ParamType>, gas: null | bigint);
+    /**
+     *  The Function selector.
+     */
+    get selector(): string;
+    format(format?: FormatType): string;
+    static getSelector(name: string, params?: Array<any>): string;
+    static from(obj: any): FunctionFragment;
+    static isFragment(value: any): value is FunctionFragment;
+}
+/**
+ *  A Fragment which represents a structure.
+ */
+export declare class StructFragment extends NamedFragment {
+    /**
+     *  @private
+     */
+    constructor(guard: any, name: string, inputs: ReadonlyArray<ParamType>);
+    format(): string;
+    static from(obj: any): StructFragment;
+    static isFragment(value: any): value is FunctionFragment;
+}

lib.commonjs/abi/fragments.js

@@ -57,7 +57,6 @@ class TokenString {
                 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
@@ -506,7 +505,7 @@ class ParamType {
     walk(value, process) {
         if (this.isArray()) {
             if (!Array.isArray(value)) {
-                throw new Error("invlaid array value");
+                throw new Error("invalid array value");
             }
             if (this.arrayLength !== -1 && value.length !== this.arrayLength) {
                 throw new Error("array is wrong length");
@@ -516,7 +515,7 @@ class ParamType {
         }
         if (this.isTuple()) {
             if (!Array.isArray(value)) {
-                throw new Error("invlaid tuple value");
+                throw new Error("invalid tuple value");
             }
             if (value.length !== this.components.length) {
                 throw new Error("array is wrong length");
@@ -529,7 +528,7 @@ class ParamType {
     #walkAsync(promises, value, process, setValue) {
         if (this.isArray()) {
             if (!Array.isArray(value)) {
-                throw new Error("invlaid array value");
+                throw new Error("invalid array value");
             }
             if (this.arrayLength !== -1 && value.length !== this.arrayLength) {
                 throw new Error("array is wrong length");
@@ -553,7 +552,7 @@ class ParamType {
             }
             else {
                 if (value == null || typeof (value) !== "object") {
-                    throw new Error("invlaid tuple value");
+                    throw new Error("invalid tuple value");
                 }
                 result = components.map((param) => {
                     if (!param.name) {

lib.commonjs/abi/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ *  Explain about ABI here...
+ *
+ *  @_section api/abi:Application Binary Interface  [about-abi]
+ *  @_navTitle: ABI
+ */
+export { AbiCoder } from "./abi-coder.js";
+export { decodeBytes32String, encodeBytes32String } from "./bytes32.js";
+export { ConstructorFragment, ErrorFragment, EventFragment, FallbackFragment, Fragment, FunctionFragment, NamedFragment, ParamType, StructFragment, } from "./fragments.js";
+export { checkResultErrors, Indexed, Interface, ErrorDescription, LogDescription, TransactionDescription, Result } from "./interface.js";
+export { Typed } from "./typed.js";
+export type { JsonFragment, JsonFragmentType, FormatType, FragmentType, ParamTypeWalkAsyncFunc, ParamTypeWalkFunc } from "./fragments.js";
+export type { InterfaceAbi, } from "./interface.js";

lib.commonjs/abi/interface.d.ts

@@ -0,0 +1,253 @@
+/**
+ *  About Interface
+ *
+ *  @_subsection api/abi:Interfaces  [interfaces]
+ */
+import { AbiCoder } from "./abi-coder.js";
+import { checkResultErrors, Result } from "./coders/abstract-coder.js";
+import { ConstructorFragment, ErrorFragment, EventFragment, FallbackFragment, Fragment, FunctionFragment, ParamType } from "./fragments.js";
+import { Typed } from "./typed.js";
+import type { BigNumberish, BytesLike, CallExceptionError, CallExceptionTransaction } from "../utils/index.js";
+import type { JsonFragment } from "./fragments.js";
+export { checkResultErrors, Result };
+export declare class LogDescription {
+    readonly fragment: EventFragment;
+    readonly name: string;
+    readonly signature: string;
+    readonly topic: string;
+    readonly args: Result;
+    constructor(fragment: EventFragment, topic: string, args: Result);
+}
+export declare 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);
+}
+export declare class ErrorDescription {
+    readonly fragment: ErrorFragment;
+    readonly name: string;
+    readonly args: Result;
+    readonly signature: string;
+    readonly selector: string;
+    constructor(fragment: ErrorFragment, selector: string, args: Result);
+}
+export declare class Indexed {
+    readonly hash: null | string;
+    readonly _isIndexed: boolean;
+    static isIndexed(value: any): value is Indexed;
+    constructor(hash: null | string);
+}
+/**
+ *  @TODO
+ */
+export type InterfaceAbi = string | ReadonlyArray<Fragment | JsonFragment | string>;
+/**
+ *  An Interface abstracts many of the low-level details for
+ *  encoding and decoding the data on the blockchain.
+ *
+ *  An ABI provides information on how to encode data to send to
+ *  a Contract, how to decode the results and events and how to
+ *  interpret revert errors.
+ *
+ *  The ABI can be specified by [any supported format](InterfaceAbi).
+ */
+export declare class Interface {
+    #private;
+    /**
+     *  All the Contract ABI members (i.e. methods, events, errors, etc).
+     */
+    readonly fragments: ReadonlyArray<Fragment>;
+    /**
+     *  The Contract constructor.
+     */
+    readonly deploy: ConstructorFragment;
+    /**
+     *  The Fallback method, if any.
+     */
+    readonly fallback: null | FallbackFragment;
+    /**
+     *  If receiving ether is supported.
+     */
+    readonly receive: boolean;
+    /**
+     *  Create a new Interface for the %%fragments%%.
+     */
+    constructor(fragments: InterfaceAbi);
+    /**
+     *  Returns the entire Human-Readable ABI, as an array of
+     *  signatures, optionally as %%minimal%% strings, which
+     *  removes parameter names and unneceesary spaces.
+     */
+    format(minimal?: boolean): Array<string>;
+    /**
+     *  Return the JSON-encoded ABI. This is the format Solidiy
+     *  returns.
+     */
+    formatJson(): string;
+    /**
+     *  The ABI coder that will be used to encode and decode binary
+     *  data.
+     */
+    getAbiCoder(): AbiCoder;
+    /**
+     *  Get the function name for %%key%%, which may be a function selector,
+     *  function name or function signature that belongs to the ABI.
+     */
+    getFunctionName(key: string): string;
+    /**
+     *  Get the [[FunctionFragment]] for %%key%%, which may be a function
+     *  selector, function name or function signature that belongs to the ABI.
+     *
+     *  If %%values%% is provided, it will use the Typed API to handle
+     *  ambiguous cases where multiple functions match by name.
+     *
+     *  If the %%key%% and %%values%% do not refine to a single function in
+     *  the ABI, this will throw.
+     */
+    getFunction(key: string, values?: Array<any | Typed>): null | FunctionFragment;
+    /**
+     *  Iterate over all functions, calling %%callback%%, sorted by their name.
+     */
+    forEachFunction(callback: (func: FunctionFragment, index: number) => void): void;
+    /**
+     *  Get the event name for %%key%%, which may be a topic hash,
+     *  event name or event signature that belongs to the ABI.
+     */
+    getEventName(key: string): string;
+    /**
+     *  Get the [[EventFragment]] for %%key%%, which may be a topic hash,
+     *  event name or event signature that belongs to the ABI.
+     *
+     *  If %%values%% is provided, it will use the Typed API to handle
+     *  ambiguous cases where multiple events match by name.
+     *
+     *  If the %%key%% and %%values%% do not refine to a single event in
+     *  the ABI, this will throw.
+     */
+    getEvent(key: string, values?: Array<any | Typed>): null | EventFragment;
+    /**
+     *  Iterate over all events, calling %%callback%%, sorted by their name.
+     */
+    forEachEvent(callback: (func: EventFragment, index: number) => void): void;
+    /**
+     *  Get the [[ErrorFragment]] for %%key%%, which may be an error
+     *  selector, error name or error signature that belongs to the ABI.
+     *
+     *  If %%values%% is provided, it will use the Typed API to handle
+     *  ambiguous cases where multiple errors match by name.
+     *
+     *  If the %%key%% and %%values%% do not refine to a single error in
+     *  the ABI, this will throw.
+     */
+    getError(key: string, values?: Array<any | Typed>): null | ErrorFragment;
+    /**
+     *  Iterate over all errors, calling %%callback%%, sorted by their name.
+     */
+    forEachError(callback: (func: ErrorFragment, index: number) => void): void;
+    _decodeParams(params: ReadonlyArray<ParamType>, data: BytesLike): Result;
+    _encodeParams(params: ReadonlyArray<ParamType>, values: ReadonlyArray<any>): string;
+    /**
+     *  Encodes a ``tx.data`` object for deploying the Contract with
+     *  the %%values%% as the constructor arguments.
+     */
+    encodeDeploy(values?: ReadonlyArray<any>): string;
+    /**
+     *  Decodes the result %%data%% (e.g. from an ``eth_call``) for the
+     *  specified error (see [[getError]] for valid values for
+     *  %%key%%).
+     *
+     *  Most developers should prefer the [[parseCallResult]] method instead,
+     *  which will automatically detect a ``CALL_EXCEPTION`` and throw the
+     *  corresponding error.
+     */
+    decodeErrorResult(fragment: ErrorFragment | string, data: BytesLike): Result;
+    /**
+     *  Encodes the transaction revert data for a call result that
+     *  reverted from the the Contract with the sepcified %%error%%
+     *  (see [[getError]] for valid values for %%fragment%%) with the %%values%%.
+     *
+     *  This is generally not used by most developers, unless trying to mock
+     *  a result from a Contract.
+     */
+    encodeErrorResult(fragment: ErrorFragment | string, values?: ReadonlyArray<any>): string;
+    /**
+     *  Decodes the %%data%% from a transaction ``tx.data`` for
+     *  the function specified (see [[getFunction]] for valid values
+     *  for %%fragment%%).
+     *
+     *  Most developers should prefer the [[parseTransaction]] method
+     *  instead, which will automatically detect the fragment.
+     */
+    decodeFunctionData(fragment: FunctionFragment | string, data: BytesLike): Result;
+    /**
+     *  Encodes the ``tx.data`` for a transaction that calls the function
+     *  specified (see [[getFunction]] for valid values for %%fragment%%) with
+     *  the %%values%%.
+     */
+    encodeFunctionData(fragment: FunctionFragment | string, values?: ReadonlyArray<any>): string;
+    /**
+     *  Decodes the result %%data%% (e.g. from an ``eth_call``) for the
+     *  specified function (see [[getFunction]] for valid values for
+     *  %%key%%).
+     *
+     *  Most developers should prefer the [[parseCallResult]] method instead,
+     *  which will automatically detect a ``CALL_EXCEPTION`` and throw the
+     *  corresponding error.
+     */
+    decodeFunctionResult(fragment: FunctionFragment | string, data: BytesLike): Result;
+    makeError(_data: BytesLike, tx: CallExceptionTransaction): CallExceptionError;
+    /**
+     *  Encodes the result data (e.g. from an ``eth_call``) for the
+     *  specified function (see [[getFunction]] for valid values
+     *  for %%fragment%%) with %%values%%.
+     *
+     *  This is generally not used by most developers, unless trying to mock
+     *  a result from a Contract.
+     */
+    encodeFunctionResult(fragment: FunctionFragment | string, values?: ReadonlyArray<any>): string;
+    encodeFilterTopics(fragment: EventFragment | string, values: ReadonlyArray<any>): Array<null | string | Array<string>>;
+    encodeEventLog(fragment: EventFragment | string, values: ReadonlyArray<any>): {
+        data: string;
+        topics: Array<string>;
+    };
+    decodeEventLog(fragment: EventFragment | string, data: BytesLike, topics?: ReadonlyArray<string>): Result;
+    /**
+     *  Parses a transaction, finding the matching function and extracts
+     *  the parameter values along with other useful function details.
+     *
+     *  If the matching function cannot be found, return null.
+     */
+    parseTransaction(tx: {
+        data: string;
+        value?: BigNumberish;
+    }): null | TransactionDescription;
+    parseCallResult(data: BytesLike): Result;
+    /**
+     *  Parses a receipt log, finding the matching event and extracts
+     *  the parameter values along with other useful event details.
+     *
+     *  If the matching event cannot be found, returns null.
+     */
+    parseLog(log: {
+        topics: Array<string>;
+        data: string;
+    }): null | LogDescription;
+    /**
+     *  Parses a revert data, finding the matching error and extracts
+     *  the parameter values along with other useful error details.
+     *
+     *  If the matching event cannot be found, returns null.
+     */
+    parseError(data: BytesLike): null | ErrorDescription;
+    /**
+     *  Creates a new [[Interface]] from the ABI %%value%%.
+     *
+     *  The %%value%% may be provided as an existing [[Interface]] object,
+     *  a JSON-encoded ABI or any Human-Readable ABI format.
+     */
+    static from(value: InterfaceAbi | Interface): Interface;
+}

lib.commonjs/abi/typed.d.ts

@@ -0,0 +1,162 @@
+/**
+ *  About typed...
+ *
+ *  @_subsection: api/abi:Typed Values
+ */
+import type { Addressable } from "../address/index.js";
+import type { BigNumberish, BytesLike } from "../utils/index.js";
+import type { Result } from "./coders/abstract-coder.js";
+export interface TypedNumber extends Typed {
+    value: number;
+    defaultValue(): number;
+    minValue(): number;
+    maxValue(): number;
+}
+export interface TypedBigInt extends Typed {
+    value: bigint;
+    defaultValue(): bigint;
+    minValue(): bigint;
+    maxValue(): bigint;
+}
+export interface TypedData extends Typed {
+    value: string;
+    defaultValue(): string;
+}
+export interface TypedString extends Typed {
+    value: string;
+    defaultValue(): string;
+}
+export declare class Typed {
+    #private;
+    readonly type: string;
+    readonly value: any;
+    readonly _typedSymbol: Symbol;
+    constructor(gaurd: any, type: string, value: any, options?: any);
+    format(): string;
+    defaultValue(): string | number | bigint | Result;
+    minValue(): string | number | bigint;
+    maxValue(): string | number | bigint;
+    isBigInt(): this is TypedBigInt;
+    isData(): this is TypedData;
+    isString(): this is TypedString;
+    get tupleName(): null | string;
+    get arrayLength(): null | number;
+    static from(type: string, value: any): Typed;
+    static uint8(v: BigNumberish): Typed;
+    static uint16(v: BigNumberish): Typed;
+    static uint24(v: BigNumberish): Typed;
+    static uint32(v: BigNumberish): Typed;
+    static uint40(v: BigNumberish): Typed;
+    static uint48(v: BigNumberish): Typed;
+    static uint56(v: BigNumberish): Typed;
+    static uint64(v: BigNumberish): Typed;
+    static uint72(v: BigNumberish): Typed;
+    static uint80(v: BigNumberish): Typed;
+    static uint88(v: BigNumberish): Typed;
+    static uint96(v: BigNumberish): Typed;
+    static uint104(v: BigNumberish): Typed;
+    static uint112(v: BigNumberish): Typed;
+    static uint120(v: BigNumberish): Typed;
+    static uint128(v: BigNumberish): Typed;
+    static uint136(v: BigNumberish): Typed;
+    static uint144(v: BigNumberish): Typed;
+    static uint152(v: BigNumberish): Typed;
+    static uint160(v: BigNumberish): Typed;
+    static uint168(v: BigNumberish): Typed;
+    static uint176(v: BigNumberish): Typed;
+    static uint184(v: BigNumberish): Typed;
+    static uint192(v: BigNumberish): Typed;
+    static uint200(v: BigNumberish): Typed;
+    static uint208(v: BigNumberish): Typed;
+    static uint216(v: BigNumberish): Typed;
+    static uint224(v: BigNumberish): Typed;
+    static uint232(v: BigNumberish): Typed;
+    static uint240(v: BigNumberish): Typed;
+    static uint248(v: BigNumberish): Typed;
+    static uint256(v: BigNumberish): Typed;
+    static uint(v: BigNumberish): Typed;
+    static int8(v: BigNumberish): Typed;
+    static int16(v: BigNumberish): Typed;
+    static int24(v: BigNumberish): Typed;
+    static int32(v: BigNumberish): Typed;
+    static int40(v: BigNumberish): Typed;
+    static int48(v: BigNumberish): Typed;
+    static int56(v: BigNumberish): Typed;
+    static int64(v: BigNumberish): Typed;
+    static int72(v: BigNumberish): Typed;
+    static int80(v: BigNumberish): Typed;
+    static int88(v: BigNumberish): Typed;
+    static int96(v: BigNumberish): Typed;
+    static int104(v: BigNumberish): Typed;
+    static int112(v: BigNumberish): Typed;
+    static int120(v: BigNumberish): Typed;
+    static int128(v: BigNumberish): Typed;
+    static int136(v: BigNumberish): Typed;
+    static int144(v: BigNumberish): Typed;
+    static int152(v: BigNumberish): Typed;
+    static int160(v: BigNumberish): Typed;
+    static int168(v: BigNumberish): Typed;
+    static int176(v: BigNumberish): Typed;
+    static int184(v: BigNumberish): Typed;
+    static int192(v: BigNumberish): Typed;
+    static int200(v: BigNumberish): Typed;
+    static int208(v: BigNumberish): Typed;
+    static int216(v: BigNumberish): Typed;
+    static int224(v: BigNumberish): Typed;
+    static int232(v: BigNumberish): Typed;
+    static int240(v: BigNumberish): Typed;
+    static int248(v: BigNumberish): Typed;
+    static int256(v: BigNumberish): Typed;
+    static int(v: BigNumberish): Typed;
+    static bytes1(v: BytesLike): Typed;
+    static bytes2(v: BytesLike): Typed;
+    static bytes3(v: BytesLike): Typed;
+    static bytes4(v: BytesLike): Typed;
+    static bytes5(v: BytesLike): Typed;
+    static bytes6(v: BytesLike): Typed;
+    static bytes7(v: BytesLike): Typed;
+    static bytes8(v: BytesLike): Typed;
+    static bytes9(v: BytesLike): Typed;
+    static bytes10(v: BytesLike): Typed;
+    static bytes11(v: BytesLike): Typed;
+    static bytes12(v: BytesLike): Typed;
+    static bytes13(v: BytesLike): Typed;
+    static bytes14(v: BytesLike): Typed;
+    static bytes15(v: BytesLike): Typed;
+    static bytes16(v: BytesLike): Typed;
+    static bytes17(v: BytesLike): Typed;
+    static bytes18(v: BytesLike): Typed;
+    static bytes19(v: BytesLike): Typed;
+    static bytes20(v: BytesLike): Typed;
+    static bytes21(v: BytesLike): Typed;
+    static bytes22(v: BytesLike): Typed;
+    static bytes23(v: BytesLike): Typed;
+    static bytes24(v: BytesLike): Typed;
+    static bytes25(v: BytesLike): Typed;
+    static bytes26(v: BytesLike): Typed;
+    static bytes27(v: BytesLike): Typed;
+    static bytes28(v: BytesLike): Typed;
+    static bytes29(v: BytesLike): Typed;
+    static bytes30(v: BytesLike): Typed;
+    static bytes31(v: BytesLike): Typed;
+    static bytes32(v: BytesLike): Typed;
+    static address(v: string | Addressable): Typed;
+    static bool(v: any): Typed;
+    static bytes(v: BytesLike): Typed;
+    static string(v: string): Typed;
+    static array(v: Array<any | Typed>, dynamic?: null | boolean): Typed;
+    static tuple(v: Array<any | Typed> | Record<string, any | Typed>, name?: string): Typed;
+    static overrides(v: Record<string, any>): Typed;
+    /**
+     *  Returns true only if %%value%% is a [[Typed]] instance.
+     */
+    static isTyped(value: any): value is Typed;
+    /**
+     *  If the value is a [[Typed]] instance, validates the underlying value
+     *  and returns it, otherwise returns value directly.
+     *
+     *  This is useful for functions that with to accept either a [[Typed]]
+     *  object or values.
+     */
+    static dereference<T>(value: Typed | T, type: string): T;
+}

lib.commonjs/address/address.d.ts

@@ -0,0 +1,55 @@
+/**
+ *  Returns a normalized and checksumed address for %%address%%.
+ *  This accepts non-checksum addresses, checksum addresses and
+ *  [[getIcapAddress]] formats.
+ *
+ *  The checksum in Ethereum uses the capitalization (upper-case
+ *  vs lower-case) of the characters within an address to encode
+ *  its checksum, which offers, on average, a checksum of 15-bits.
+ *
+ *  If %%address%% contains both upper-case and lower-case, it is
+ *  assumed to already be a checksum address and its checksum is
+ *  validated, and if the address fails its expected checksum an
+ *  error is thrown.
+ *
+ *  If you wish the checksum of %%address%% to be ignore, it should
+ *  be converted to lower-case (i.e. ``.toLowercase()``) before
+ *  being passed in. This should be a very rare situation though,
+ *  that you wish to bypass the safegaurds in place to protect
+ *  against an address that has been incorrectly copied from another
+ *  source.
+ *
+ *  @example:
+ *    // Adds the checksum (via upper-casing specific letters)
+ *    getAddress("0x8ba1f109551bd432803012645ac136ddd64dba72")
+ *    //_result:
+ *
+ *    // Converts ICAP address and adds checksum
+ *    getAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36");
+ *    //_result:
+ *
+ *    // Throws an error if an address contains mixed case,
+ *    // but the checksum fails
+ *    getAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
+ *    //_error:
+ */
+export declare function getAddress(address: string): string;
+/**
+ *  The [ICAP Address format](link-icap) format is an early checksum
+ *  format which attempts to be compatible with the banking
+ *  industry [IBAN format](link-wiki-iban) for bank accounts.
+ *
+ *  It is no longer common or a recommended format.
+ *
+ *  @example:
+ *    getIcapAddress("0x8ba1f109551bd432803012645ac136ddd64dba72");
+ *    //_result:
+ *
+ *    getIcapAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36");
+ *    //_result:
+ *
+ *    // Throws an error if the ICAP checksum is wrong
+ *    getIcapAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK37");
+ *    //_error:
+ */
+export declare function getIcapAddress(address: string): string;

lib.commonjs/address/address.js

@@ -134,7 +134,7 @@ exports.getAddress = getAddress;
 /**
  *  The [ICAP Address format](link-icap) format is an early checksum
  *  format which attempts to be compatible with the banking
- *  industry [IBAN format](link-wiki-iban] for bank accounts.
+ *  industry [IBAN format](link-wiki-iban) for bank accounts.
  *
  *  It is no longer common or a recommended format.
  *

lib.commonjs/address/checks.d.ts

@@ -0,0 +1,80 @@
+import type { Addressable, AddressLike, NameResolver } from "./index.js";
+/**
+ *  Returns true if %%value%% is an object which implements the
+ *  [[Addressable]] interface.
+ *
+ *  @example:
+ *    // Wallets and AbstractSigner sub-classes
+ *    isAddressable(Wallet.createRandom())
+ *    //_result:
+ *
+ *    // Contracts
+ *    contract = new Contract("dai.tokens.ethers.eth", [ ], provider)
+ *    isAddressable(contract)
+ *    //_result:
+ */
+export declare function isAddressable(value: any): value is Addressable;
+/**
+ *  Returns true if %%value%% is a valid address.
+ *
+ *  @example:
+ *    // Valid address
+ *    isAddress("0x8ba1f109551bD432803012645Ac136ddd64DBA72")
+ *    //_result:
+ *
+ *    // Valid ICAP address
+ *    isAddress("XE65GB6LDNXYOFTX0NSV3FUWKOWIXAMJK36")
+ *    //_result:
+ *
+ *    // Invalid checksum
+ *    isAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBa72")
+ *    //_result:
+ *
+ *    // Invalid ICAP checksum
+ *    isAddress("0x8Ba1f109551bD432803012645Ac136ddd64DBA72")
+ *    //_result:
+ *
+ *    // Not an address (an ENS name requires a provided and an
+ *    // asynchronous API to access)
+ *    isAddress("ricmoo.eth")
+ *    //_result:
+ */
+export declare function isAddress(value: any): value is string;
+/**
+ *  Resolves to an address for the %%target%%, which may be any
+ *  supported address type, an [[Addressable]] or a Promise which
+ *  resolves to an address.
+ *
+ *  If an ENS name is provided, but that name has not been correctly
+ *  configured a [[UnconfiguredNameError]] is thrown.
+ *
+ *  @example:
+ *    addr = "0x6B175474E89094C44Da98b954EedeAC495271d0F"
+ *
+ *    // Addresses are return synchronously
+ *    resolveAddress(addr, provider)
+ *    //_result:
+ *
+ *    // Address promises are resolved asynchronously
+ *    resolveAddress(Promise.resolve(addr))
+ *    //_result:
+ *
+ *    // ENS names are resolved asynchronously
+ *    resolveAddress("dai.tokens.ethers.eth", provider)
+ *    //_result:
+ *
+ *    // Addressable objects are resolved asynchronously
+ *    contract = new Contract(addr, [ ])
+ *    resolveAddress(contract, provider)
+ *    //_result:
+ *
+ *    // Unconfigured ENS names reject
+ *    resolveAddress("nothing-here.ricmoo.eth", provider)
+ *    //_error:
+ *
+ *    // ENS names require a NameResolver object passed in
+ *    // (notice the provider was omitted)
+ *    resolveAddress("nothing-here.ricmoo.eth")
+ *    //_error:
+ */
+export declare function resolveAddress(target: AddressLike, resolver?: null | NameResolver): string | Promise<string>;

lib.commonjs/address/contract-address.d.ts

@@ -0,0 +1,47 @@
+import type { BigNumberish, BytesLike } from "../utils/index.js";
+/**
+ *  Returns the address that would result from a ``CREATE`` for %%tx%%.
+ *
+ *  This can be used to compute the address a contract will be
+ *  deployed to by an EOA when sending a deployment transaction (i.e.
+ *  when the ``to`` address is ``null``).
+ *
+ *  This can also be used to compute the address a contract will be
+ *  deployed to by a contract, by using the contract's address as the
+ *  ``to`` and the contract's nonce.
+ *
+ *  @example
+ *    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72";
+ *    nonce = 5;
+ *
+ *    getCreateAddress({ from, nonce });
+ *    //_result:
+ */
+export declare function getCreateAddress(tx: {
+    from: string;
+    nonce: BigNumberish;
+}): string;
+/**
+ *  Returns the address that would result from a ``CREATE2`` operation
+ *  with the given %%from%%, %%salt%% and %%initCodeHash%%.
+ *
+ *  To compute the %%initCodeHash%% from a contract's init code, use
+ *  the [[keccak256]] function.
+ *
+ *  For a quick overview and example of ``CREATE2``, see [[link-ricmoo-wisps]].
+ *
+ *  @example
+ *    // The address of the contract
+ *    from = "0x8ba1f109551bD432803012645Ac136ddd64DBA72"
+ *
+ *    // The salt
+ *    salt = id("HelloWorld")
+ *
+ *    // The hash of the initCode
+ *    initCode = "0x6394198df16000526103ff60206004601c335afa6040516060f3";
+ *    initCodeHash = keccak256(initCode)
+ *
+ *    getCreate2Address(from, salt, initCodeHash)
+ *    //_result:
+ */
+export declare function getCreate2Address(_from: string, _salt: BytesLike, _initCodeHash: BytesLike): string;

lib.commonjs/address/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ *  Addresses are a fundamental part of interacting with Ethereum. They
+ *  represent the gloabal identity of Externally Owned Accounts (accounts
+ *  backed by a private key) and contracts.
+ *
+ *  The Ethereum Naming Service (ENS) provides an interconnected ecosystem
+ *  of contracts, standards and libraries which enable looking up an
+ *  address for an ENS name.
+ *
+ *  These functions help convert between various formats, validate
+ *  addresses and safely resolve ENS names.
+ *
+ *  @_section: api/address:Addresses  [about-addresses]
+ */
+/**
+ *  An interface for objects which have an address, and can
+ *  resolve it asyncronously.
+ *
+ *  This allows objects such as [[Signer]] or [[Contract]] to
+ *  be used most places an address can be, for example getting
+ *  the [balance](Provider-getBalance).
+ */
+export interface Addressable {
+    /**
+     *  Get the object address.
+     */
+    getAddress(): Promise<string>;
+}
+/**
+ *  Anything that can be used to return or resolve an address.
+ */
+export type AddressLike = string | Promise<string> | Addressable;
+/**
+ *  An interface for any object which can resolve an ENS name.
+ */
+export interface NameResolver {
+    /**
+     *  Resolve to the address for the ENS %%name%%.
+     *
+     *  Resolves to ``null`` if the name is unconfigued. Use
+     *  [[resolveAddress]] (passing this object as %%resolver%%) to
+     *  throw for names that are unconfigured.
+     */
+    resolveName(name: string): Promise<null | string>;
+}
+export { getAddress, getIcapAddress } from "./address.js";
+export { getCreateAddress, getCreate2Address } from "./contract-address.js";
+export { isAddressable, isAddress, resolveAddress } from "./checks.js";

lib.commonjs/constants/addresses.d.ts

@@ -0,0 +1,6 @@
+/**
+ *  A constant for the zero address.
+ *
+ *  (**i.e.** ``"0x0000000000000000000000000000000000000000"``)
+ */
+export declare const ZeroAddress: string;

lib.commonjs/constants/hashes.d.ts

@@ -0,0 +1,6 @@
+/**
+ *  A constant for the zero hash.
+ *
+ *  (**i.e.** ``"0x0000000000000000000000000000000000000000000000000000000000000000"``)
+ */
+export declare const ZeroHash: string;

lib.commonjs/constants/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ *  Some common constants useful for Ethereum.
+ *
+ *  @_section: api/constants: Constants  [about-constants]
+ */
+export { ZeroAddress } from "./addresses.js";
+export { ZeroHash } from "./hashes.js";
+export { N, WeiPerEther, MaxUint256, MinInt256, MaxInt256 } from "./numbers.js";
+export { EtherSymbol, MessagePrefix } from "./strings.js";

lib.commonjs/constants/numbers.d.ts

@@ -0,0 +1,30 @@
+/**
+ *  A constant for the order N for the secp256k1 curve.
+ *
+ *  (**i.e.** ``0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n``)
+ */
+export declare const N: bigint;
+/**
+ *  A constant for the number of wei in a single ether.
+ *
+ *  (**i.e.** ``1000000000000000000n``)
+ */
+export declare const WeiPerEther: bigint;
+/**
+ *  A constant for the maximum value for a ``uint256``.
+ *
+ *  (**i.e.** ``0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn``)
+ */
+export declare const MaxUint256: bigint;
+/**
+ *  A constant for the minimum value for an ``int256``.
+ *
+ *  (**i.e.** ``-8000000000000000000000000000000000000000000000000000000000000000n``)
+ */
+export declare const MinInt256: bigint;
+/**
+ *  A constant for the maximum value for an ``int256``.
+ *
+ *  (**i.e.** ``0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn``)
+ */
+export declare const MaxInt256: bigint;

lib.commonjs/constants/strings.d.ts

@@ -0,0 +1,12 @@
+/**
+ *  A constant for the ether symbol (normalized using NFKC).
+ *
+ *  (**i.e.** ``"\\u039e"``)
+ */
+export declare const EtherSymbol: string;
+/**
+ *  A constant for the [[link-eip-191]] personal message prefix.
+ *
+ *  (**i.e.** ``"\\x19Ethereum Signed Message:\\n"``)
+ */
+export declare const MessagePrefix: string;

lib.commonjs/contract/contract.d.ts

@@ -0,0 +1,50 @@
+import { Interface } from "../abi/index.js";
+import { Log, TransactionResponse } from "../providers/provider.js";
+import { ContractTransactionResponse, EventLog } from "./wrappers.js";
+import type { EventFragment, FunctionFragment, InterfaceAbi, ParamType } from "../abi/index.js";
+import type { Addressable } from "../address/index.js";
+import type { EventEmitterable, Listener } from "../utils/index.js";
+import type { BlockTag, ContractRunner } from "../providers/index.js";
+import type { ContractEventName, ContractInterface, ContractMethod, ContractEvent, ContractTransaction, WrappedFallback } from "./types.js";
+/**
+ *  @_ignore:
+ */
+export declare function copyOverrides<O extends string = "data" | "to">(arg: any, allowed?: Array<string>): Promise<Omit<ContractTransaction, O>>;
+/**
+ *  @_ignore:
+ */
+export declare function resolveArgs(_runner: null | ContractRunner, inputs: ReadonlyArray<ParamType>, args: Array<any>): Promise<Array<any>>;
+declare const internal: unique symbol;
+export declare class BaseContract implements Addressable, EventEmitterable<ContractEventName> {
+    readonly target: string | Addressable;
+    readonly interface: Interface;
+    readonly runner: null | ContractRunner;
+    readonly filters: Record<string, ContractEvent>;
+    readonly [internal]: any;
+    readonly fallback: null | WrappedFallback;
+    constructor(target: string | Addressable, abi: Interface | InterfaceAbi, runner?: null | ContractRunner, _deployTx?: null | TransactionResponse);
+    connect(runner: null | ContractRunner): BaseContract;
+    getAddress(): Promise<string>;
+    getDeployedCode(): Promise<null | string>;
+    waitForDeployment(): Promise<this>;
+    deploymentTransaction(): null | ContractTransactionResponse;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getEvent(key: string | EventFragment): ContractEvent;
+    queryTransaction(hash: string): Promise<Array<EventLog>>;
+    queryFilter(event: ContractEventName, fromBlock?: BlockTag, toBlock?: BlockTag): Promise<Array<EventLog | Log>>;
+    on(event: ContractEventName, listener: Listener): Promise<this>;
+    once(event: ContractEventName, listener: Listener): Promise<this>;
+    emit(event: ContractEventName, ...args: Array<any>): Promise<boolean>;
+    listenerCount(event?: ContractEventName): Promise<number>;
+    listeners(event?: ContractEventName): Promise<Array<Listener>>;
+    off(event: ContractEventName, listener?: Listener): Promise<this>;
+    removeAllListeners(event?: ContractEventName): Promise<this>;
+    addListener(event: ContractEventName, listener: Listener): Promise<this>;
+    removeListener(event: ContractEventName, listener: Listener): Promise<this>;
+    static buildClass<T = ContractInterface>(abi: InterfaceAbi): new (target: string, runner?: null | ContractRunner) => BaseContract & Omit<T, keyof BaseContract>;
+    static from<T = ContractInterface>(target: string, abi: InterfaceAbi, runner?: null | ContractRunner): BaseContract & Omit<T, keyof BaseContract>;
+}
+declare const Contract_base: new (target: string, abi: InterfaceAbi, runner?: ContractRunner | null | undefined) => BaseContract & Omit<ContractInterface, keyof BaseContract>;
+export declare class Contract extends Contract_base {
+}
+export {};

lib.commonjs/contract/contract.js

@@ -58,9 +58,6 @@ class PreparedTopicFilter {
 // D = The type the default call will return (i.e. R for view/pure,
 //     TransactionResponse otherwise)
 //export interface ContractMethod<A extends Array<any> = Array<any>, R = any, D extends R | ContractTransactionResponse = ContractTransactionResponse> {
-function _WrappedMethodBase() {
-    return Function;
-}
 function getRunner(value, feature) {
     if (value == null) {
         return null;
@@ -112,98 +109,142 @@ async function resolveArgs(_runner, inputs, args) {
     }));
 }
 exports.resolveArgs = resolveArgs;
-class WrappedFallback {
-    _contract;
-    constructor(contract) {
-        (0, index_js_3.defineProperties)(this, { _contract: contract });
-        const proxy = new Proxy(this, {
-            // Perform send when called
-            apply: async (target, thisArg, args) => {
-                return await target.send(...args);
-            },
-        });
-        return proxy;
-    }
-    async populateTransaction(overrides) {
+function buildWrappedFallback(contract) {
+    const populateTransaction = async function (overrides) {
         // If an overrides was passed in, copy it and normalize the values
         const tx = (await copyOverrides(overrides, ["data"]));
-        tx.to = await this._contract.getAddress();
-        const iface = this._contract.interface;
+        tx.to = await contract.getAddress();
+        const iface = contract.interface;
         // Only allow payable contracts to set non-zero value
         const payable = iface.receive || (iface.fallback && iface.fallback.payable);
         (0, index_js_3.assertArgument)(payable || (tx.value || BN_0) === BN_0, "cannot send value to non-payable contract", "overrides.value", tx.value);
         // Only allow fallback contracts to set non-empty data
         (0, index_js_3.assertArgument)(iface.fallback || (tx.data || "0x") === "0x", "cannot send data to receive-only contract", "overrides.data", tx.data);
         return tx;
-    }
-    async staticCall(overrides) {
-        const runner = getRunner(this._contract.runner, "call");
+    };
+    const staticCall = async function (overrides) {
+        const runner = getRunner(contract.runner, "call");
         (0, index_js_3.assert)(canCall(runner), "contract runner does not support calling", "UNSUPPORTED_OPERATION", { operation: "call" });
-        const tx = await this.populateTransaction(overrides);
+        const tx = await populateTransaction(overrides);
         try {
             return await runner.call(tx);
         }
         catch (error) {
             if ((0, index_js_3.isCallException)(error) && error.data) {
+                throw contract.interface.makeError(error.data, tx);
+            }
+            throw error;
+        }
+    };
+    const send = async function (overrides) {
+        const runner = contract.runner;
+        (0, index_js_3.assert)(canSend(runner), "contract runner does not support sending transactions", "UNSUPPORTED_OPERATION", { operation: "sendTransaction" });
+        const tx = await runner.sendTransaction(await populateTransaction(overrides));
+        const provider = getProvider(contract.runner);
+        // @TODO: the provider can be null; make a custom dummy provider that will throw a
+        // meaningful error
+        return new wrappers_js_1.ContractTransactionResponse(contract.interface, provider, tx);
+    };
+    const estimateGas = async function (overrides) {
+        const runner = getRunner(contract.runner, "estimateGas");
+        (0, index_js_3.assert)(canEstimate(runner), "contract runner does not support gas estimation", "UNSUPPORTED_OPERATION", { operation: "estimateGas" });
+        return await runner.estimateGas(await populateTransaction(overrides));
+    };
+    const method = async (overrides) => {
+        return await send(overrides);
+    };
+    (0, index_js_3.defineProperties)(method, {
+        _contract: contract,
+        estimateGas,
+        populateTransaction,
+        send, staticCall
+    });
+    return method;
+}
+/*
+class WrappedFallback {
+
+    constructor (contract: BaseContract) {
+        defineProperties<WrappedFallback>(this, { _contract: contract });
+
+        const proxy = new Proxy(this, {
+            // Perform send when called
+            apply: async (target, thisArg, args: Array<any>) => {
+                return await target.send(...args);
+            },
+        });
+
+        return proxy;
+    }
+
+    async populateTransaction(overrides?: Omit<TransactionRequest, "to">): Promise<ContractTransaction> {
+        // If an overrides was passed in, copy it and normalize the values
+
+        const tx: ContractTransaction = <any>(await copyOverrides<"data">(overrides, [ "data" ]));
+        tx.to = await this._contract.getAddress();
+
+        const iface = this._contract.interface;
+
+        // Only allow payable contracts to set non-zero value
+        const payable = iface.receive || (iface.fallback && iface.fallback.payable);
+        assertArgument(payable || (tx.value || BN_0) === BN_0,
+          "cannot send value to non-payable contract", "overrides.value", tx.value);
+
+        // Only allow fallback contracts to set non-empty data
+        assertArgument(iface.fallback || (tx.data || "0x") === "0x",
+          "cannot send data to receive-only contract", "overrides.data", tx.data);
+
+        return tx;
+    }
+
+    async staticCall(overrides?: Omit<TransactionRequest, "to">): Promise<string> {
+        const runner = getRunner(this._contract.runner, "call");
+        assert(canCall(runner), "contract runner does not support calling",
+            "UNSUPPORTED_OPERATION", { operation: "call" });
+
+        const tx = await this.populateTransaction(overrides);
+
+        try {
+            return await runner.call(tx);
+        } catch (error: any) {
+            if (isCallException(error) && error.data) {
                 throw this._contract.interface.makeError(error.data, tx);
             }
             throw error;
         }
     }
-    async send(overrides) {
+
+    async send(overrides?: Omit<TransactionRequest, "to">): Promise<ContractTransactionResponse> {
         const runner = this._contract.runner;
-        (0, index_js_3.assert)(canSend(runner), "contract runner does not support sending transactions", "UNSUPPORTED_OPERATION", { operation: "sendTransaction" });
+        assert(canSend(runner), "contract runner does not support sending transactions",
+            "UNSUPPORTED_OPERATION", { operation: "sendTransaction" });
+
         const tx = await runner.sendTransaction(await this.populateTransaction(overrides));
         const provider = getProvider(this._contract.runner);
         // @TODO: the provider can be null; make a custom dummy provider that will throw a
         // meaningful error
-        return new wrappers_js_1.ContractTransactionResponse(this._contract.interface, provider, tx);
+        return new ContractTransactionResponse(this._contract.interface, <Provider>provider, tx);
     }
-    async estimateGas(overrides) {
+
+    async estimateGas(overrides?: Omit<TransactionRequest, "to">): Promise<bigint> {
         const runner = getRunner(this._contract.runner, "estimateGas");
-        (0, index_js_3.assert)(canEstimate(runner), "contract runner does not support gas estimation", "UNSUPPORTED_OPERATION", { operation: "estimateGas" });
+        assert(canEstimate(runner), "contract runner does not support gas estimation",
+            "UNSUPPORTED_OPERATION", { operation: "estimateGas" });
+
         return await runner.estimateGas(await this.populateTransaction(overrides));
     }
 }
-class WrappedMethod extends _WrappedMethodBase() {
-    name = ""; // Investigate!
-    _contract;
-    _key;
-    constructor(contract, key) {
-        super();
-        (0, index_js_3.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) => {
-                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() {
-        const fragment = this._contract.interface.getFunction(this._key);
+*/
+function buildWrappedMethod(contract, key) {
+    const getFragment = function (...args) {
+        const fragment = contract.interface.getFunction(key, args);
         (0, index_js_3.assert)(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
             operation: "fragment"
         });
         return fragment;
-    }
-    getFragment(...args) {
-        const fragment = this._contract.interface.getFunction(this._key, args);
-        (0, index_js_3.assert)(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
-            operation: "fragment"
-        });
-        return fragment;
-    }
-    async populateTransaction(...args) {
-        const fragment = this.getFragment(...args);
+    };
+    const populateTransaction = async function (...args) {
+        const fragment = getFragment(...args);
         // If an overrides was passed in, copy it and normalize the values
         let overrides = {};
         if (fragment.inputs.length + 1 === args.length) {
@@ -212,88 +253,109 @@ class WrappedMethod extends _WrappedMethodBase() {
         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);
+        const resolvedArgs = await resolveArgs(contract.runner, fragment.inputs, args);
         return Object.assign({}, overrides, await (0, index_js_3.resolveProperties)({
-            to: this._contract.getAddress(),
-            data: this._contract.interface.encodeFunctionData(fragment, resolvedArgs)
+            to: contract.getAddress(),
+            data: contract.interface.encodeFunctionData(fragment, resolvedArgs)
         }));
-    }
-    async staticCall(...args) {
-        const result = await this.staticCallResult(...args);
+    };
+    const staticCall = async function (...args) {
+        const result = await staticCallResult(...args);
         if (result.length === 1) {
             return result[0];
         }
         return result;
-    }
-    async send(...args) {
-        const runner = this._contract.runner;
+    };
+    const send = async function (...args) {
+        const runner = contract.runner;
         (0, index_js_3.assert)(canSend(runner), "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);
+        const tx = await runner.sendTransaction(await populateTransaction(...args));
+        const provider = getProvider(contract.runner);
         // @TODO: the provider can be null; make a custom dummy provider that will throw a
         // meaningful error
-        return new wrappers_js_1.ContractTransactionResponse(this._contract.interface, provider, tx);
-    }
-    async estimateGas(...args) {
-        const runner = getRunner(this._contract.runner, "estimateGas");
+        return new wrappers_js_1.ContractTransactionResponse(contract.interface, provider, tx);
+    };
+    const estimateGas = async function (...args) {
+        const runner = getRunner(contract.runner, "estimateGas");
         (0, index_js_3.assert)(canEstimate(runner), "contract runner does not support gas estimation", "UNSUPPORTED_OPERATION", { operation: "estimateGas" });
-        return await runner.estimateGas(await this.populateTransaction(...args));
-    }
-    async staticCallResult(...args) {
-        const runner = getRunner(this._contract.runner, "call");
+        return await runner.estimateGas(await populateTransaction(...args));
+    };
+    const staticCallResult = async function (...args) {
+        const runner = getRunner(contract.runner, "call");
         (0, index_js_3.assert)(canCall(runner), "contract runner does not support calling", "UNSUPPORTED_OPERATION", { operation: "call" });
-        const tx = await this.populateTransaction(...args);
+        const tx = await populateTransaction(...args);
         let result = "0x";
         try {
             result = await runner.call(tx);
         }
         catch (error) {
             if ((0, index_js_3.isCallException)(error) && error.data) {
-                throw this._contract.interface.makeError(error.data, tx);
+                throw contract.interface.makeError(error.data, tx);
             }
             throw error;
         }
-        const fragment = this.getFragment(...args);
-        return this._contract.interface.decodeFunctionResult(fragment, result);
-    }
+        const fragment = getFragment(...args);
+        return contract.interface.decodeFunctionResult(fragment, result);
+    };
+    const method = async (...args) => {
+        const fragment = getFragment(...args);
+        if (fragment.constant) {
+            return await staticCall(...args);
+        }
+        return await send(...args);
+    };
+    (0, index_js_3.defineProperties)(method, {
+        name: contract.interface.getFunctionName(key),
+        _contract: contract, _key: key,
+        getFragment,
+        estimateGas,
+        populateTransaction,
+        send, staticCall, staticCallResult,
+    });
+    // Only works on non-ambiguous keys (refined fragment is always non-ambiguous)
+    Object.defineProperty(method, "fragment", {
+        configurable: false,
+        enumerable: true,
+        get: () => {
+            const fragment = contract.interface.getFunction(key);
+            (0, index_js_3.assert)(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
+                operation: "fragment"
+            });
+            return fragment;
+        }
+    });
+    return method;
 }
-function _WrappedEventBase() {
-    return Function;
-}
-class WrappedEvent extends _WrappedEventBase() {
-    name = ""; // @TODO: investigate 
-    _contract;
-    _key;
-    constructor(contract, key) {
-        super();
-        (0, index_js_3.defineProperties)(this, {
-            name: contract.interface.getEventName(key),
-            _contract: contract, _key: key
-        });
-        return new Proxy(this, {
-            // Perform the default operation for this fragment type
-            apply: (target, thisArg, args) => {
-                return new PreparedTopicFilter(contract, target.getFragment(...args), args);
-            },
-        });
-    }
-    // Only works on non-ambiguous keys
-    get fragment() {
-        const fragment = this._contract.interface.getEvent(this._key);
+function buildWrappedEvent(contract, key) {
+    const getFragment = function (...args) {
+        const fragment = contract.interface.getEvent(key, args);
         (0, index_js_3.assert)(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
             operation: "fragment"
         });
         return fragment;
-    }
-    getFragment(...args) {
-        const fragment = this._contract.interface.getEvent(this._key, args);
-        (0, index_js_3.assert)(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
-            operation: "fragment"
-        });
-        return fragment;
-    }
+    };
+    const method = function (...args) {
+        return new PreparedTopicFilter(contract, getFragment(...args), args);
+    };
+    (0, index_js_3.defineProperties)(method, {
+        name: contract.interface.getEventName(key),
+        _contract: contract, _key: key,
+        getFragment
+    });
+    // Only works on non-ambiguous keys (refined fragment is always non-ambiguous)
+    Object.defineProperty(method, "fragment", {
+        configurable: false,
+        enumerable: true,
+        get: () => {
+            const fragment = contract.interface.getEvent(key);
+            (0, index_js_3.assert)(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
+                operation: "fragment"
+            });
+            return fragment;
+        }
+    });
+    return method;
 }
-;
 // 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
@@ -553,7 +615,7 @@ class BaseContract {
         });
         (0, index_js_3.defineProperties)(this, { filters });
         (0, index_js_3.defineProperties)(this, {
-            fallback: ((iface.receive || iface.fallback) ? (new WrappedFallback(this)) : null)
+            fallback: ((iface.receive || iface.fallback) ? (buildWrappedFallback(this)) : null)
         });
         // Return a Proxy that will respond to functions
         return new Proxy(this, {
@@ -621,13 +683,14 @@ class BaseContract {
         if (typeof (key) !== "string") {
             key = key.format();
         }
-        return (new WrappedMethod(this, key));
+        const func = buildWrappedMethod(this, key);
+        return func;
     }
     getEvent(key) {
         if (typeof (key) !== "string") {
             key = key.format();
         }
-        return (new WrappedEvent(this, key));
+        return buildWrappedEvent(this, key);
     }
     async queryTransaction(hash) {
         // Is this useful?

lib.commonjs/contract/factory.d.ts

@@ -0,0 +1,21 @@
+import { Interface } from "../abi/index.js";
+import { BaseContract } 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";
+export declare class ContractFactory<A extends Array<any> = Array<any>, I = BaseContract> {
+    readonly interface: Interface;
+    readonly bytecode: string;
+    readonly runner: null | ContractRunner;
+    constructor(abi: Interface | InterfaceAbi, bytecode: BytesLike | {
+        object: string;
+    }, runner?: null | ContractRunner);
+    getDeployTransaction(...args: ContractMethodArgs<A>): Promise<ContractDeployTransaction>;
+    deploy(...args: ContractMethodArgs<A>): Promise<BaseContract & {
+        deploymentTransaction(): ContractTransactionResponse;
+    } & Omit<I, keyof BaseContract>>;
+    connect(runner: null | ContractRunner): ContractFactory<A, I>;
+    static fromSolidity<A extends Array<any> = Array<any>, I = ContractInterface>(output: any, runner?: ContractRunner): ContractFactory<A, I>;
+}

lib.commonjs/contract/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ *  About contracts...
+ *
+ *  @_section: api/contract:Contracts  [about-contracts]
+ */
+export { BaseContract, Contract } from "./contract.js";
+export { ContractFactory } from "./factory.js";
+export { ContractEventPayload, ContractUnknownEventPayload, ContractTransactionReceipt, ContractTransactionResponse, EventLog, } from "./wrappers.js";
+export type { BaseContractMethod, ConstantContractMethod, PostfixOverrides, ContractEvent, ContractEventArgs, ContractEventName, ContractDeployTransaction, ContractInterface, ContractMethod, ContractMethodArgs, ContractTransaction, DeferredTopicFilter, Overrides, WrappedFallback } from "./types.js";

lib.commonjs/contract/types.d.ts

@@ -0,0 +1,55 @@
+import type { EventFragment, FunctionFragment, Result, Typed } from "../abi/index.js";
+import type { TransactionRequest, PreparedTransactionRequest, TopicFilter } from "../providers/index.js";
+import type { ContractTransactionResponse } from "./wrappers.js";
+export type ContractEventName = string | ContractEvent | TopicFilter | DeferredTopicFilter;
+export interface ContractInterface {
+    [name: string]: BaseContractMethod;
+}
+export interface DeferredTopicFilter {
+    getTopicFilter(): Promise<TopicFilter>;
+    fragment: EventFragment;
+}
+export interface ContractTransaction extends PreparedTransactionRequest {
+    to: string;
+    data: string;
+    from?: string;
+}
+export interface ContractDeployTransaction extends Omit<ContractTransaction, "to"> {
+}
+export interface Overrides extends Omit<TransactionRequest, "to" | "data"> {
+}
+export type PostfixOverrides<A extends Array<any>> = A | [...A, Overrides];
+export type ContractMethodArgs<A extends Array<any>> = PostfixOverrides<{
+    [I in keyof A]-?: A[I] | Typed;
+}>;
+export interface BaseContractMethod<A extends Array<any> = Array<any>, R = any, D extends R | ContractTransactionResponse = R | ContractTransactionResponse> {
+    (...args: ContractMethodArgs<A>): Promise<D>;
+    name: string;
+    fragment: FunctionFragment;
+    getFragment(...args: ContractMethodArgs<A>): FunctionFragment;
+    populateTransaction(...args: ContractMethodArgs<A>): Promise<ContractTransaction>;
+    staticCall(...args: ContractMethodArgs<A>): Promise<R>;
+    send(...args: ContractMethodArgs<A>): Promise<ContractTransactionResponse>;
+    estimateGas(...args: ContractMethodArgs<A>): Promise<bigint>;
+    staticCallResult(...args: ContractMethodArgs<A>): Promise<Result>;
+}
+export interface ContractMethod<A extends Array<any> = Array<any>, R = any, D extends R | ContractTransactionResponse = R | ContractTransactionResponse> extends BaseContractMethod<A, R, D> {
+}
+export interface ConstantContractMethod<A extends Array<any>, R = any> extends ContractMethod<A, R, R> {
+}
+export type ContractEventArgs<A extends Array<any>> = {
+    [I in keyof A]?: A[I] | Typed | null;
+};
+export interface ContractEvent<A extends Array<any> = Array<any>> {
+    (...args: ContractEventArgs<A>): DeferredTopicFilter;
+    name: string;
+    fragment: EventFragment;
+    getFragment(...args: ContractEventArgs<A>): EventFragment;
+}
+export interface WrappedFallback {
+    (overrides?: Omit<TransactionRequest, "to">): Promise<ContractTransactionResponse>;
+    populateTransaction(overrides?: Omit<TransactionRequest, "to">): Promise<ContractTransaction>;
+    staticCall(overrides?: Omit<TransactionRequest, "to">): Promise<string>;
+    send(overrides?: Omit<TransactionRequest, "to">): Promise<ContractTransactionResponse>;
+    estimateGas(overrides?: Omit<TransactionRequest, "to">): Promise<bigint>;
+}

lib.commonjs/contract/wrappers.d.ts

@@ -0,0 +1,40 @@
+import { Block, Log, TransactionReceipt, TransactionResponse } from "../providers/provider.js";
+import { 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 declare class EventLog extends Log {
+    readonly interface: Interface;
+    readonly fragment: EventFragment;
+    readonly args: Result;
+    constructor(log: Log, iface: Interface, fragment: EventFragment);
+    get eventName(): string;
+    get eventSignature(): string;
+}
+export declare class ContractTransactionReceipt extends TransactionReceipt {
+    #private;
+    constructor(iface: Interface, provider: Provider, tx: TransactionReceipt);
+    get logs(): Array<EventLog | Log>;
+}
+export declare class ContractTransactionResponse extends TransactionResponse {
+    #private;
+    constructor(iface: Interface, provider: Provider, tx: TransactionResponse);
+    wait(confirms?: number): Promise<null | ContractTransactionReceipt>;
+}
+export declare class ContractUnknownEventPayload extends EventPayload<ContractEventName> {
+    readonly log: Log;
+    constructor(contract: BaseContract, listener: null | Listener, filter: ContractEventName, log: Log);
+    getBlock(): Promise<Block>;
+    getTransaction(): Promise<TransactionResponse>;
+    getTransactionReceipt(): Promise<TransactionReceipt>;
+}
+export declare class ContractEventPayload extends ContractUnknownEventPayload {
+    readonly fragment: EventFragment;
+    readonly log: EventLog;
+    readonly args: Result;
+    constructor(contract: BaseContract, listener: null | Listener, filter: ContractEventName, fragment: EventFragment, _log: Log);
+    get eventName(): string;
+    get eventSignature(): string;
+}

lib.commonjs/contract/wrappers.js

@@ -19,16 +19,16 @@ class EventLog extends provider_js_1.Log {
 }
 exports.EventLog = EventLog;
 class ContractTransactionReceipt extends provider_js_1.TransactionReceipt {
-    #interface;
+    #iface;
     constructor(iface, provider, tx) {
         super(tx, provider);
-        this.#interface = iface;
+        this.#iface = iface;
     }
     get logs() {
         return super.logs.map((log) => {
-            const fragment = log.topics.length ? this.#interface.getEvent(log.topics[0]) : null;
+            const fragment = log.topics.length ? this.#iface.getEvent(log.topics[0]) : null;
             if (fragment) {
-                return new EventLog(log, this.#interface, fragment);
+                return new EventLog(log, this.#iface, fragment);
             }
             else {
                 return log;
@@ -38,17 +38,17 @@ class ContractTransactionReceipt extends provider_js_1.TransactionReceipt {
 }
 exports.ContractTransactionReceipt = ContractTransactionReceipt;
 class ContractTransactionResponse extends provider_js_1.TransactionResponse {
-    #interface;
+    #iface;
     constructor(iface, provider, tx) {
         super(tx, provider);
-        this.#interface = iface;
+        this.#iface = iface;
     }
     async wait(confirms) {
         const receipt = await super.wait();
         if (receipt == null) {
             return null;
         }
-        return new ContractTransactionReceipt(this.#interface, this.provider, receipt);
+        return new ContractTransactionReceipt(this.#iface, this.provider, receipt);
     }
 }
 exports.ContractTransactionResponse = ContractTransactionResponse;

lib.commonjs/contract/wrappers.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrappers.js","sourceRoot":"","sources":["../../src.ts/contract/wrappers.ts"],"names":[],"mappings":";;;AAAA,sEAAsE;AACtE,yBAAyB;AACzB,0DAEkC;AAClC,gDAAmE;AAYnE,MAAa,QAAS,SAAQ,iBAAG;IACpB,SAAS,CAAa;IACtB,QAAQ,CAAiB;IACzB,IAAI,CAAU;IAEvB,YAAY,GAAQ,EAAE,KAAgB,EAAE,QAAuB;QAC3D,KAAK,CAAC,GAAG,EAAE,GAAG,CAAC,QAAQ,CAAC,CAAC;QACzB,MAAM,IAAI,GAAG,KAAK,CAAC,cAAc,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;QAClE,IAAA,2BAAgB,EAAW,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC;IAC3E,CAAC;IAED,IAAI,SAAS,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;IACtD,IAAI,cAAc,KAAa,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CAClE;AAbD,4BAaC;AAED,MAAa,0BAA2B,SAAQ,gCAAkB;IACrD,UAAU,CAAY;IAE/B,YAAY,KAAgB,EAAE,QAAkB,EAAE,EAAsB;QACpE,KAAK,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;QACpB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC5B,CAAC;IAED,IAAI,IAAI;QACJ,OAAO,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE;YAC1B,MAAM,QAAQ,GAAG,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAA,CAAC,CAAC,IAAI,CAAC;YACnF,IAAI,QAAQ,EAAE;gBACV,OAAO,IAAI,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;aACtD;iBAAM;gBACH,OAAO,GAAG,CAAC;aACd;QACL,CAAC,CAAC,CAAC;IACP,CAAC;CAEJ;AAnBD,gEAmBC;AAED,MAAa,2BAA4B,SAAQ,iCAAmB;IACvD,UAAU,CAAY;IAE/B,YAAY,KAAgB,EAAE,QAAkB,EAAE,EAAuB;QACrE,KAAK,CAAC,EAAE,EAAE,QAAQ,CAAC,CAAC;QACpB,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC;IAC5B,CAAC;IAED,KAAK,CAAC,IAAI,CAAC,QAAiB;QACxB,MAAM,OAAO,GAAG,MAAM,KAAK,CAAC,IAAI,EAAE,CAAC;QACnC,IAAI,OAAO,IAAI,IAAI,EAAE;YAAE,OAAO,IAAI,CAAC;SAAE;QACrC,OAAO,IAAI,0BAA0B,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IACnF,CAAC;CACJ;AAbD,kEAaC;AAED,MAAc,2BAA4B,SAAQ,uBAA+B;IACpE,GAAG,CAAO;IAEnB,YAAY,QAAsB,EAAE,QAAyB,EAAE,MAAyB,EAAE,GAAQ;QAC9F,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,CAAC,CAAC;QAClC,IAAA,2BAAgB,EAA8B,IAAI,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC;IACjE,CAAC;IAED,KAAK,CAAC,QAAQ;QACV,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,QAAQ,EAAE,CAAC;IACrC,CAAC;IAED,KAAK,CAAC,cAAc;QAChB,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,cAAc,EAAE,CAAC;IAC3C,CAAC;IAED,KAAK,CAAC,qBAAqB;QACvB,OAAO,MAAM,IAAI,CAAC,GAAG,CAAC,qBAAqB,EAAE,CAAC;IAClD,CAAC;CACJ;AAnBD,kEAmBC;AAED,MAAa,oBAAqB,SAAQ,2BAA2B;IAMjE,YAAY,QAAsB,EAAE,QAAyB,EAAE,MAAyB,EAAE,QAAuB,EAAE,IAAS;QACxH,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC;QACpF,MAAM,IAAI,GAAG,QAAQ,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;QACzF,IAAA,2BAAgB,EAAuB,IAAI,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;IACrE,CAAC;IAED,IAAI,SAAS;QACT,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC;IAC9B,CAAC;IAED,IAAI,cAAc;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;IAClC,CAAC;CACJ;AAnBD,oDAmBC"}
+{"version":3,"file":"wrappers.js","sourceRoot":"","sources":["../../src.ts/contract/wrappers.ts"],"names":[],"mappings":"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"}

lib.commonjs/crypto/crypto-browser.d.ts

@@ -0,0 +1,14 @@
+declare global {
+    interface Window {
+    }
+    const window: Window;
+    const self: Window;
+}
+export interface CryptoHasher {
+    update(data: Uint8Array): CryptoHasher;
+    digest(): Uint8Array;
+}
+export declare function createHash(algo: string): CryptoHasher;
+export declare function createHmac(_algo: string, key: Uint8Array): CryptoHasher;
+export declare function pbkdf2Sync(password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, _algo: "sha256" | "sha512"): Uint8Array;
+export declare function randomBytes(length: number): Uint8Array;

lib.commonjs/crypto/crypto.d.ts

@@ -0,0 +1 @@
+export { createHash, createHmac, pbkdf2Sync, randomBytes } from "crypto";

lib.commonjs/crypto/hmac.d.ts

@@ -0,0 +1,24 @@
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Return the HMAC for %%data%% using the %%key%% key with the underlying
+ *  %%algo%% used for compression.
+ *
+ *  @example:
+ *    key = id("some-secret")
+ *
+ *    // Compute the HMAC
+ *    computeHmac("sha256", key, "0x1337")
+ *    //_result:
+ *
+ *    // To compute the HMAC of UTF-8 data, the data must be
+ *    // converted to UTF-8 bytes
+ *    computeHmac("sha256", key, toUtf8Bytes("Hello World"))
+ *    //_result:
+ *
+ */
+export declare function computeHmac(algorithm: "sha256" | "sha512", _key: BytesLike, _data: BytesLike): string;
+export declare namespace computeHmac {
+    var _: (algorithm: "sha256" | "sha512", key: Uint8Array, data: Uint8Array) => BytesLike;
+    var lock: () => void;
+    var register: (func: (algorithm: "sha256" | "sha512", key: Uint8Array, data: Uint8Array) => BytesLike) => void;
+}

lib.commonjs/crypto/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ *  A fundamental building block of Ethereum is the underlying
+ *  cryptographic primitives.
+ *
+ *  @_section: api/crypto:Cryptographic Functions   [about-crypto]
+ */
+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";
+declare function lock(): void;
+export { lock };
+export type { ProgressCallback } from "./scrypt.js";
+export type { SignatureLike } from "./signature.js";

lib.commonjs/crypto/keccak.d.ts

@@ -0,0 +1,34 @@
+/**
+ *  Cryptographic hashing functions
+ *
+ *  @_subsection: api/crypto:Hash Functions [about-crypto-hashing]
+ */
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Compute the cryptographic KECCAK256 hash of %%data%%.
+ *
+ *  The %%data%% **must** be a data representation, to compute the
+ *  hash of UTF-8 data use the [[id]] function.
+ *
+ *  @returns DataHexstring
+ *  @example:
+ *    keccak256("0x")
+ *    //_result:
+ *
+ *    keccak256("0x1337")
+ *    //_result:
+ *
+ *    keccak256(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ *    // Strings are assumed to be DataHexString, otherwise it will
+ *    // throw. To hash UTF-8 data, see the note above.
+ *    keccak256("Hello World")
+ *    //_error:
+ */
+export declare function keccak256(_data: BytesLike): string;
+export declare namespace keccak256 {
+    var _: (data: Uint8Array) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (data: Uint8Array) => BytesLike) => void;
+}

lib.commonjs/crypto/pbkdf2.d.ts

@@ -0,0 +1,34 @@
+/**
+ *  A **Password-Based Key-Derivation Function** is designed to create
+ *  a sequence of bytes suitible as a **key** from a human-rememberable
+ *  password.
+ *
+ *  @_subsection: api/crypto:Passwords  [about-pbkdf]
+ */
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Return the [[link-pbkdf2]] for %%keylen%% bytes for %%password%% using
+ *  the %%salt%% and using %%iterations%% of %%algo%%.
+ *
+ *  This PBKDF is outdated and should not be used in new projects, but is
+ *  required to decrypt older files.
+ *
+ *  @example:
+ *    // The password must be converted to bytes, and it is generally
+ *    // best practices to ensure the string has been normalized. Many
+ *    // formats explicitly indicate the normalization form to use.
+ *    password = "hello"
+ *    passwordBytes = toUtf8Bytes(password, "NFKC")
+ *
+ *    salt = id("some-salt")
+ *
+ *    // Compute the PBKDF2
+ *    pbkdf2(passwordBytes, salt, 1024, 16, "sha256")
+ *    //_result:
+ */
+export declare function pbkdf2(_password: BytesLike, _salt: BytesLike, iterations: number, keylen: number, algo: "sha256" | "sha512"): string;
+export declare namespace pbkdf2 {
+    var _: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512") => BytesLike;
+    var lock: () => void;
+    var register: (func: (password: Uint8Array, salt: Uint8Array, iterations: number, keylen: number, algo: "sha256" | "sha512") => BytesLike) => void;
+}

lib.commonjs/crypto/random.d.ts

@@ -0,0 +1,13 @@
+/**
+ *  Return %%length%% bytes of cryptographically secure random data.
+ *
+ *  @example:
+ *    randomBytes(8)
+ *    //_result:
+ */
+export declare function randomBytes(length: number): Uint8Array;
+export declare namespace randomBytes {
+    var _: (length: number) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (length: number) => Uint8Array) => void;
+}

lib.commonjs/crypto/ripemd160.d.ts

@@ -0,0 +1,24 @@
+import type { BytesLike } from "../utils/index.js";
+/**
+ *  Compute the cryptographic RIPEMD-160 hash of %%data%%.
+ *
+ *  @_docloc: api/crypto:Hash Functions
+ *  @returns DataHexstring
+ *
+ *  @example:
+ *    ripemd160("0x")
+ *    //_result:
+ *
+ *    ripemd160("0x1337")
+ *    //_result:
+ *
+ *    ripemd160(new Uint8Array([ 0x13, 0x37 ]))
+ *    //_result:
+ *
+ */
+export declare function ripemd160(_data: BytesLike): string;
+export declare namespace ripemd160 {
+    var _: (data: Uint8Array) => Uint8Array;
+    var lock: () => void;
+    var register: (func: (data: Uint8Array) => BytesLike) => void;
+}