dequanto 0.2.50 → 0.2.52

package/lib/types/utils/$gas.d.ts

@@ -1,4 +1,4 @@
-import { TEth } from '../models/TEth';
+import { TEth } from 'dequanto/models/TEth';
 export declare namespace $gas {
     function getUsed(receipt: TEth.TxReceipt, txData?: {
         gasPrice?: any;

package/lib/types/utils/$hex.d.ts

@@ -1,4 +1,4 @@
-import { TEth } from '../models/TEth';
+import { TEth } from 'dequanto/models/TEth';
 export declare namespace $hex {
     const ZERO = "0x";
     const ZERO_Bytes32 = "0x0000000000000000000000000000000000000000000000000000000000000000";

package/lib/types/utils/$is.d.ts

@@ -1,4 +1,4 @@
-import { TEth } from '../models/TEth';
+import { TEth } from 'dequanto/models/TEth';
 export declare namespace $is {
     function Number<T>(val: number | any): val is number;
     function notNull<T>(val: T): boolean;

package/lib/types/utils/$number.d.ts

@@ -1,4 +1,4 @@
-import { TEth } from '../models/TEth';
+import { TEth } from 'dequanto/models/TEth';
 export declare namespace $number {
     function div(a: number, b: number, digits?: number): number;
     /**

package/lib/types/utils/$promise.d.ts

@@ -1,8 +1,9 @@
-import { TError } from '../models/TError';
+import { TError } from 'dequanto/models/TError';
 import { class_EventEmitter } from 'atma-utils';
 import { TFnWithCallback } from './types';
+import { $date } from './$date';
 export declare namespace $promise {
-    function wait(ms: any): Promise<unknown>;
+    function wait(mix: number | `${number}${$date.TTimespanType}`): Promise<unknown>;
     function fromEvent<T extends Pick<class_EventEmitter, 'on' | 'off'>, TArgs extends Parameters<T['on']>>(eventEmitter: T, event: TArgs[0]): Promise<any>;
     function fromCallback<TResult, TArgs extends any[]>(fn: TFnWithCallback<TArgs, TResult>, ...args: TArgs): Promise<TResult>;
     function fromCallbackCtx<TResult, TArgs extends any[]>(ctx: any, fn: TFnWithCallback<TArgs, TResult>, ...args: TArgs): Promise<TResult>;

package/lib/types/utils/$ref.d.ts

@@ -1,4 +1,4 @@
-import { IEIP6963Provider } from '../rpc/transports/compatibility/IEIP6963Provider';
+import { IEIP6963Provider } from 'dequanto/rpc/transports/compatibility/IEIP6963Provider';
 export type TGlobal = {
     ethereum: IEIP6963Provider;
     addEventListener: Window['addEventListener'];

package/lib/types/utils/$require.d.ts

@@ -1,6 +1,6 @@
-import { IToken } from '../models/IToken';
-import { TAddress } from '../models/TAddress';
-import { TEth } from '../models/TEth';
+import { IToken } from 'dequanto/models/IToken';
+import { TAddress } from 'dequanto/models/TAddress';
+import { TEth } from 'dequanto/models/TEth';
 export declare namespace $require {
     function Number<T>(val: T, message?: string, opts?: {
         min?: T;

package/lib/types/utils/$sig.d.ts

@@ -1,9 +1,9 @@
-import { TEth } from '../models/TEth';
-import { $rlp } from '../abi/$rlp';
-import type { Web3Client } from '../clients/Web3Client';
-import type { Rpc, RpcTypes } from '../rpc/Rpc';
-import { TPlatform } from '../models/TPlatform';
-import { EoAccount } from '../models/TAccount';
+import { TEth } from 'dequanto/models/TEth';
+import { $rlp } from 'dequanto/abi/$rlp';
+import type { Web3Client } from 'dequanto/clients/Web3Client';
+import type { Rpc, RpcTypes } from 'dequanto/rpc/Rpc';
+import { TPlatform } from 'dequanto/models/TPlatform';
+import { EoAccount } from 'dequanto/models/TAccount';
 export declare namespace $sig {
     function signTypedData(typedData: Partial<RpcTypes.TypedData>, account: TEth.EoAccount, rpc?: Rpc): Promise<TSignature>;
     function sign(message: string | Uint8Array, account: TEth.EoAccount, rpc?: Rpc): Promise<TSignature>;

package/lib/types/utils/$traces.d.ts

@@ -1,5 +1,5 @@
-import { TClientDebugTraces } from '../clients/debug/ClientDebugMethods';
-import { TEth } from '../models/TEth';
+import { TClientDebugTraces } from 'dequanto/clients/debug/ClientDebugMethods';
+import { TEth } from 'dequanto/models/TEth';
 export declare namespace $traces {
     type TAbiMeta = {
         name?: string;

package/lib/types/utils/$txData.d.ts

@@ -1,4 +1,4 @@
-import { TEth } from '../models/TEth';
+import { TEth } from 'dequanto/models/TEth';
 export declare namespace $txData {
     function getJson(txData: TEth.TxLike, defaults?: {
         defaultTxType?: number;

package/lib/types/utils/types.d.ts

@@ -1,6 +1,6 @@
-import { IAccount } from '../models/TAccount';
-import { TEth } from '../models/TEth';
-import { TxWriter } from '../txs/TxWriter';
+import { IAccount } from 'dequanto/models/TAccount';
+import { TEth } from 'dequanto/models/TEth';
+import { TxWriter } from 'dequanto/txs/TxWriter';
 type NoneMethodKeys<T> = {
     [P in keyof T]: T[P] extends ((...args: any[]) => any) ? never : P;
 }[keyof T];

package/lib/types/wallets/EIP6963ProviderFactory.d.ts

@@ -1,8 +1,8 @@
-import { TAddress } from '../models/TAddress';
-import { TEth } from '../models/TEth';
-import { TGlobal } from '../utils/$ref';
+import { TAddress } from 'dequanto/models/TAddress';
+import { TEth } from 'dequanto/models/TEth';
+import { TGlobal } from 'dequanto/utils/$ref';
 import { class_EventEmitter } from 'atma-utils';
-import { IEIP6963Provider } from '../rpc/transports/compatibility/IEIP6963Provider';
+import { IEIP6963Provider } from 'dequanto/rpc/transports/compatibility/IEIP6963Provider';
 interface EIP6963ProviderInfo {
     rdns?: string;
     uuid: string;
@@ -41,6 +41,7 @@ export declare class EIP6963ProviderFactory extends class_EventEmitter<IProvider
     getProviderOrFirst(id?: string): EIP6963ProviderDetail;
     getProvider(id?: string, optional?: boolean): EIP6963ProviderDetail;
     private getId;
+    private matchesId;
     private addEventListeners;
     private removeEventListeners;
 }

package/lib/types/wallets/Signer.d.ts

@@ -1,5 +1,5 @@
-import { TEth } from '../models/TEth';
-import { Rpc, RpcTypes } from '../rpc/Rpc';
+import { TEth } from 'dequanto/models/TEth';
+import { Rpc, RpcTypes } from 'dequanto/rpc/Rpc';
 export declare class Signer implements TEth.IRpcSigner {
     opts: {
         rpc?: Rpc;

package/lib/types/wallets/Wallet.d.ts

@@ -1,8 +1,8 @@
-import { IBlockchainExplorer } from '../explorer/IBlockchainExplorer';
-import { Web3Client } from '../clients/Web3Client';
-import { TAddress } from '../models/TAddress';
-import { TokensService } from '../tokens/TokensService';
-import { TPlatform } from '../models/TPlatform';
+import { IBlockchainExplorer } from 'dequanto/explorer/IBlockchainExplorer';
+import { Web3Client } from 'dequanto/clients/Web3Client';
+import { TAddress } from 'dequanto/models/TAddress';
+import { TokensService } from 'dequanto/tokens/TokensService';
+import { TPlatform } from 'dequanto/models/TPlatform';
 export declare class Wallet {
     account: {
         platform: TPlatform;

package/lib/types/wallets/WalletService.d.ts

@@ -1,4 +1,4 @@
-import { IToken } from '../models/IToken';
+import { IToken } from 'dequanto/models/IToken';
 import { Wallet } from './Wallet';
 export declare class WalletService {
     wallet: Wallet;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "dequanto",
-    "version": "0.2.50",
+    "version": "0.2.52",
     "author": {
         "name": "Alex Kit",
         "email": "alex.kit@atmajs.com"
@@ -45,14 +45,14 @@
         "@openzeppelin/contracts": "^4.9.3",
         "@types/node": "^20.12.11",
         "@types/sinon": "^10.0.13",
-        "app-bundler": "^0.2.13",
+        "app-bundler": "^0.2.24",
         "atma": "^0.15.22",
         "atma-io-middleware-base": "^1.0.51",
         "atma-io-middleware-condcomments": "^1.2.8",
         "atma-io-middleware-importer": "^1.1.38",
         "atma-io-middleware-uglify": "^1.1.25",
         "atma-loader-ts": "^1.2.6",
-        "atma-utest": "^0.21.30",
+        "atma-utest": "^0.21.37",
         "dts-bundle": "^0.7.3",
         "ethers": "^5.5.1",
         "hardhat": "^2.28.6",
@@ -72,7 +72,7 @@
         "a-di": "^1.0.29",
         "alot": "^0.3.12",
         "appcfg": "^0.5.12",
-        "atma-io": "^1.3.7",
+        "atma-io": "^1.3.10",
         "atma-utils": "^0.2.65",
         "class-json": "^0.4.1",
         "memd": "^0.3.16",

package/skills/README.md

@@ -0,0 +1,45 @@
+# Install The Dequanto Skill
+
+The portable skill is the complete [dequanto](dequanto/) directory. It includes `SKILL.md`, `INDEX.md`, `references/`, and `examples/`. It can stay in this repository; no separate repository or server is needed.
+
+## Install From This Checkout
+
+Run from the dequanto repository root in PowerShell:
+
+```powershell
+# Codex: available across your projects.
+New-Item -ItemType Directory -Force "$HOME/.agents/skills" | Out-Null
+Copy-Item -Recurse ./skills/dequanto "$HOME/.agents/skills/"
+```
+
+For a project-specific Codex installation, copy the folder to `<project>/.agents/skills/dequanto`. For Claude Code, use `<project>/.claude/skills/dequanto`. Copy the entire folder, including its resources.
+
+Use a destination where `dequanto` does not already exist. When updating, replace the previous skill directory with the new complete directory so removed resources do not remain.
+
+In Codex, invoke `$dequanto` or let Codex select it for relevant tasks. Restart Codex if the installed skill does not appear. See the [Codex skill documentation](https://learn.chatgpt.com/docs/build-skills).
+
+## Install From GitHub With Codex
+
+After the skill directory has been committed and pushed, ask Codex:
+
+```text
+$skill-installer Install the dequanto skill from
+https://github.com/0xweb-org/dequanto/tree/master/skills/dequanto
+```
+
+Installation provides agent instructions and examples. Install the `dequanto` npm dependency separately in the project where you use it. Examples run as tests inside the dequanto repository. In other projects, adapt their generated-contract imports and fixture paths; see the skill index for prerequisites.
+
+## Maintain And Test
+
+Edit `skills/dequanto/SKILL.md`, `INDEX.md`, `references/`, and `examples/` directly. This directory is the single source of truth and the installable skill; no bundling or synchronization step is needed.
+
+Use published `dequanto/...` imports. The repository test runner maps them to `src/...` through `tsconfig-build.json`, so examples exercise the current source.
+
+Run a focused example from the repository root:
+
+```sh
+npx atma test skills/dequanto/examples/hardhat-debug.spec.ts
+npm run typecheck -- --pretty false
+```
+
+Examples using forks require RPC access; deployment and generation examples may also require the repository fixtures and Hardhat configuration.

package/{docs/ai → skills/dequanto}/INDEX.md

@@ -11,17 +11,21 @@ Before using an unfamiliar dequanto API, verify the exact signature in `src/` or
 | Goal | Use | Reference | Examples |
 | --- | --- | --- | --- |
 | Configure RPC endpoints, explorer keys, or custom chains | `Config.fetch`, `ConfigDefaults`, `RPC_<PLATFORM>` env vars, `blockchainExplorer` | `src/config/ConfigDefaults.ts` | `examples/config.spec.ts` |
-| Create an RPC client, read blocks, balances, logs, storage, or raw tx data | `Web3ClientFactory`, `Web3Client`, chain clients | `references/rpc-clients.md` | `examples/rpc-read.spec.ts` |
+| Create an RPC client; read blocks, balances, logs, storage, or raw tx data; resolve blocks by date | `Web3ClientFactory`, `Web3Client`, `BlockDateResolver`, chain clients | `references/rpc-clients.md` | `examples/rpc-read.spec.ts` |
+| Develop contracts or experiment on a Hardhat fork; impersonate accounts, change balances/storage, mine, or roll back | `Web3ClientFactory`, `client.debug`, `$erc20.setBalanceAny` | `references/hardhat.md` | `examples/hardhat-debug.spec.ts`, `examples/hardhat-fork.spec.ts` |
 | Call a smart contract | generated contract classes extending `ContractBase`, or `ContractReader` for ad hoc ABI calls | `references/contracts.md` | `examples/contract-read.spec.ts` |
 | Send a contract transaction | generated write methods returning `TxWriter`; use `$receipt()` when the receipt is needed | `references/contracts.md`, `references/transactions.md` | `examples/contract-write.spec.ts` |
 | Generate typed contract classes | `Generator`, `HardhatProvider`, 0xweb-generated classes | `references/generation.md` | `examples/generate-contract-class.spec.ts` |
 | Deploy contracts and proxies | `HardhatProvider`, `Deployments`, `ensure`, `ensureWithProxy`, `ensureWithBeacon` | `references/deployments.md` | `examples/deploy-contract.spec.ts` |
 | Build, sign, save, submit, or inspect transactions | `TxDataBuilder`, `TxWriter`, `TokenTransferService` | `references/transactions.md` | `examples/send-transaction.spec.ts` |
+| Subscribe to typed contract events, live logs, new blocks, or pending transactions over WebSocket | `on<EventName>`, `onLog`, `client.subscribe`, `Rpc.eth_subscribe` | `references/live-events.md` | `examples/live-events.spec.ts` |
 | Fetch or cache historical contract events | generated `getPastLogs*` helpers or `EventsIndexer` | `references/events-indexing.md` | `examples/index-events.spec.ts` |
 | Fetch ABI/source/creation data from an explorer | `BlockchainExplorerFactory`, `BlockchainExplorer`, `ContractAbiProvider` | `references/explorer.md` | `examples/explorer-abi.spec.ts` |
-| Read Solidity storage, structs, mappings, arrays, or diamond storage | `SlotsParser`, `SlotsStorage`, generated storage readers | `references/storage.md` | `examples/storage-read.spec.ts` |
+| Encode/decode ABI data, hash Solidity values, validate inputs, manipulate hex, work with dates, sign data, or capture promise errors | `$abi`, `$contract`, `$require`, `$hex`, `$date`, `$sig`, `$promise` | `references/utils.md` | `examples/utils.spec.ts` |
+| Read Solidity storage, structs, mappings, arrays, or diamond storage | `SlotsParser`, `SlotsStorage`, generated storage readers | `references/storage.md` | `examples/storage.spec.ts` |
 | Work with tokens and balances | `TokensService`, `TokensServiceFactory`, `TokenTransferService`, generated ERC20 wrappers | `references/tokens-accounts.md` | `examples/token-transfer.spec.ts` |
 | Work with accounts, signing, Safe, or ERC-4337 | `ChainAccountService`, `$sig`, `GnosisSafeHandler`, `SafeTx`, `Erc4337Service`, `Erc4337TxWriter` | `references/safe-erc4337.md`, `references/tokens-accounts.md` | `examples/safe-batch.spec.ts`, `examples/erc4337-userop.spec.ts` |
+| Connect a browser wallet (MetaMask, Rabby, etc.) or build a dApp; request accounts, switch chains, or sign/send txs from browser | `client.wallet`, `EIP6963ProviderFactory`, `WalletClient` | `references/browser.md` | `examples/browser-wallet.spec.ts` |
 | Convert code from ethers or viem habits | Use the dequanto equivalents instead of adding external clients | `references/migration-from-ethers-viem.md` | all examples |
 
 ## Source Of Truth
@@ -32,6 +36,14 @@ Before using an unfamiliar dequanto API, verify the exact signature in `src/` or
 - Tests under `test/` are often the best runnable examples.
 - Generated contract clients are published under `dequanto/prebuilt/...` and can be imported or required by subpath in the same way.
 
+## Installed Skill Context
+
+When this directory is installed as a skill, `references/` and `examples/` are relative to the skill directory. Paths under `src/`, `test/`, and `0xc/` identify files in the dequanto repository and are not bundled resources.
+
+In a consuming project, inspect the installed package's `lib/types/` declarations (typically `node_modules/dequanto/lib/types/`) instead of assuming the project's `src/` contains dequanto. Import package APIs through `dequanto/...`.
+
+Examples are executable `UTest` tests when run from the dequanto repository root. Some need generated contracts, Solidity/artifact fixtures, Hardhat configuration, or RPC access. Reuse their relevant code in the target project; replace repository-relative generated-contract imports and fixture paths with that project's equivalents. The installed skill provides guidance, not a standalone runnable test suite.
+
 ## Agent Workflow
 
 1. Identify the goal from the task router.

package/{docs/ai/skill → skills}/dequanto/SKILL.md

@@ -10,12 +10,20 @@ Use dequanto as the primary EVM toolkit.
 ## Workflow
 
 1. Identify the requested blockchain task.
-2. Read `../../INDEX.md` to choose the dequanto surface.
-3. Read the matching file in `../../references/`.
-4. Reuse the nearest example from `../../examples/`.
-5. Verify unfamiliar APIs in `src/` or `lib/types/` before writing code.
+2. Read `./INDEX.md` to choose the dequanto surface.
+3. Read the matching file in `./references/`.
+4. Reuse the nearest example from `./examples/`.
+5. Verify unfamiliar APIs against the target project's installed dequanto package. See the path conventions below.
 6. After TypeScript edits in the dequanto repo, run `npm run typecheck -- --pretty false`.
 
+## Paths And Example Usage
+
+Resolve `./INDEX.md`, `./references/`, and `./examples/` relative to this skill directory, regardless of the working directory.
+
+Source paths such as `src/models/TAccount.ts` refer to the dequanto repository, not this skill directory. In a consuming project, resolve the installed `dequanto` package and inspect its corresponding `lib/types/**/*.d.ts` declarations; a typical location is `node_modules/dequanto/lib/types/`. Use the installed version as the API source of truth.
+
+Examples use published `dequanto/...` imports. They retain the repository's `UTest` harness and may reference generated `0xc/` contracts or `test/fixtures/` files that are not bundled. Adapt the relevant function to the target project's runner, generated contracts, and fixtures. Do not execute examples directly from the installed skill directory or interpret repository-relative imports as installed resource paths.
+
 ## Defaults
 
 - Load configuration before any RPC, explorer, indexing, token, or contract action. Prefer `await Config.fetch()` when preparing the runtime, or `await Web3ClientFactory.getAsync(platform)` when creating a chain client because it loads configuration internally.
@@ -34,24 +42,29 @@ Use dequanto as the primary EVM toolkit.
 - Account agents can be chained. For example, a Timelock account can use a Safe account as `operator`, so the initial calldata is wrapped first as Timelock calldata and then as Safe transaction calldata.
 - Use `EventsIndexer` for resumable historical event indexing.
 - Use `BlockchainExplorerFactory` for explorer ABI, source, creation, transactions, and transfers.
-- Use `SlotsParser` and `SlotsStorage` for Solidity storage decoding.
+- Prefer generated `contract.storage` readers and `storage.$set(name, value)` when available; use `SlotsParser` and `SlotsStorage` for manual Solidity layouts.
 - Use `Deployments` for idempotent deployments, proxy deployments, beacon deployments, and verification.
 - Use dequanto account-agent flows when the account type says `safe`, `timelock`, or `erc4337`.
+- For browser and dApp workflows, use `client.wallet` (`WalletClient`) and `EIP6963ProviderFactory` to discover injected wallets, connect accounts, switch chains, and delegate signing.
 
 ## Reference Routing
 
-- Contract reads, writes, generated helper facets: `../../references/contracts.md`
-- Configuration, RPC endpoint, and explorer setup: `../../examples/config.spec.ts`, `src/config/ConfigDefaults.ts`
-- RPC clients, blocks, balances, raw logs, subscriptions: `../../references/rpc-clients.md`
-- Transaction builders, tx writer lifecycle, receipts, nonces: `../../references/transactions.md`
-- Contract generation: `../../references/generation.md`
-- Deployment and proxy flows: `../../references/deployments.md`
-- Historical events and indexing: `../../references/events-indexing.md`
-- Explorer integration: `../../references/explorer.md`
-- Solidity storage: `../../references/storage.md`
-- Tokens and accounts: `../../references/tokens-accounts.md`
-- Safe and ERC-4337: `../../references/safe-erc4337.md`
-- Translating ethers/viem habits: `../../references/migration-from-ethers-viem.md`
+- Contract reads, writes, generated helper facets: `./references/contracts.md`
+- Configuration, RPC endpoint, and explorer setup: `./examples/config.spec.ts`, `src/config/ConfigDefaults.ts`
+- Hardhat development, forks, impersonation, balance/storage changes, mining, snapshots: `./references/hardhat.md`
+- RPC clients, blocks, balances, raw logs, subscriptions: `./references/rpc-clients.md`
+- Transaction builders, tx writer lifecycle, receipts, nonces: `./references/transactions.md`
+- Contract generation: `./references/generation.md`
+- Deployment and proxy flows: `./references/deployments.md`
+- WebSocket endpoints, generated live event streams, and low-level subscriptions: `./references/live-events.md`
+- Historical events and indexing: `./references/events-indexing.md`
+- Explorer integration: `./references/explorer.md`
+- ABI, hashing, validation, hex, dates, signing, and promise helpers: `./references/utils.md`
+- Solidity storage: `./references/storage.md`
+- Tokens and accounts: `./references/tokens-accounts.md`
+- Safe and ERC-4337: `./references/safe-erc4337.md`
+- Browser wallet and dApp integration: `./references/browser.md`
+- Translating ethers/viem habits: `./references/migration-from-ethers-viem.md`
 
 ## Rules
 

package/skills/dequanto/examples/browser-wallet.spec.ts

@@ -0,0 +1,42 @@
+import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
+import { TokenTransferService } from 'dequanto/tokens/TokenTransferService';
+import { $require } from 'dequanto/utils/$require';
+import { $sig } from 'dequanto/utils/$sig';
+import { $bigint } from 'dequanto/utils/$bigint';
+import { MockWallet } from '../../../test/eip6963/MockWallet';
+
+// In browser applications (dApps), dequanto discovers injected wallets via EIP-6963 / EIP-1193.
+// When an account is connected to client.wallet, TxWriter routes transactions to the browser wallet
+// for signing and submission without needing a private key.
+UTest({
+    async 'connect to an injected browser wallet and send a transaction' () {
+        const client = await Web3ClientFactory.getAsync('hh:memory');
+
+        // Setup mock injected provider (simulates MetaMask or Rabby announcing via EIP-6963)
+        const mockWallet = new MockWallet(client);
+        const walletAccount = mockWallet.addAccount();
+        const recipient = $sig.$account.generate();
+
+        await client.debug.setBalance(walletAccount.address, 10n ** 18n);
+        mockWallet.unlockAccount(walletAccount);
+        mockWallet.announce();
+
+        // 1. Discover available wallets
+        const providers = await client.wallet.getProviders();
+        $require.True(providers.some(x => x.info.uuid === mockWallet.uuid));
+
+        // 2. Connect wallet (calls eth_requestAccounts)
+        const accounts = await client.wallet.connect(mockWallet.uuid);
+        $require.True(client.wallet.isConnected(walletAccount.address));
+        $require.eq(accounts[0], walletAccount.address);
+
+        // 3. Send transaction from browser wallet (no private key required)
+        const transfer = new TokenTransferService(client);
+        const tx = await transfer.transfer({ address: walletAccount.address }, recipient.address, 'ETH', 0.05);
+        const receipt = await tx.wait();
+
+        $require.Hex(receipt.transactionHash);
+        const recipientBalance = await client.getBalance(recipient.address);
+        $require.eq($bigint.toEther(recipientBalance), 0.05);
+    }
+});

package/{docs/ai → skills/dequanto}/examples/config.spec.ts

@@ -1,8 +1,8 @@
-import { Config } from '@dequanto/config/Config';
-import { IRpcConfig } from '@dequanto/clients/ClientPool';
-import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
-import { $require } from '@dequanto/utils/$require';
-import { BlockchainExplorerFactory } from '@dequanto/explorer/BlockchainExplorerFactory';
+import { Config } from 'dequanto/config/Config';
+import { IRpcConfig } from 'dequanto/clients/ClientPool';
+import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
+import { $require } from 'dequanto/utils/$require';
+import { BlockchainExplorerFactory } from 'dequanto/explorer/BlockchainExplorerFactory';
 
 UTest({
     async 'load default configuration before RPC actions' () {

package/{docs/ai → skills/dequanto}/examples/contract-read.spec.ts

@@ -1,14 +1,14 @@
-import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
-import { ContractClassFactory } from '@dequanto/contracts/ContractClassFactory';
+import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
+import { ContractClassFactory } from 'dequanto/contracts/ContractClassFactory';
 // dequanto ships prebuilt TypeScript clients for all OpenZeppelin contracts.
-import { ERC20 } from '@dequanto/prebuilt/openzeppelin/ERC20';
+import { ERC20 } from 'dequanto/prebuilt/openzeppelin/ERC20';
 // Use 0xweb CLI to download and generate simple TypeScript clients for verified contracts from Etherscan-compatible explorers:
 // 0xweb install <address> --name AavePool --chain eth --save-sources false
 import { AavePool } from '../../../0xc/eth/AavePool/AavePool';
-import { $abi } from '@dequanto/abi/$abi';
-import { $require } from '@dequanto/utils/$require';
-import type { TEth } from '@dequanto/models/TEth';
-import { $address } from '@dequanto/utils/$address';
+import { $abi } from 'dequanto/abi/$abi';
+import { $require } from 'dequanto/utils/$require';
+import type { TEth } from 'dequanto/models/TEth';
+import { $address } from 'dequanto/utils/$address';
 
 const USDC = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48' as const;
 const AAVE_POOL = '0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2' as const;

package/{docs/ai → skills/dequanto}/examples/contract-write.spec.ts

@@ -1,11 +1,11 @@
-import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
-import { ContractReader } from '@dequanto/contracts/ContractReader';
-import { ERC20 } from '@dequanto/prebuilt/openzeppelin/ERC20';
+import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
+import { ContractReader } from 'dequanto/contracts/ContractReader';
+import { ERC20 } from 'dequanto/prebuilt/openzeppelin/ERC20';
 import { AavePool } from '../../../0xc/eth/AavePool/AavePool';
-import type { TEth } from '@dequanto/models/TEth';
-import { $account } from '@dequanto/utils/$account';
-import { $address } from '@dequanto/utils/$address';
-import { $require } from '@dequanto/utils/$require';
+import type { TEth } from 'dequanto/models/TEth';
+import { $account } from 'dequanto/utils/$account';
+import { $address } from 'dequanto/utils/$address';
+import { $require } from 'dequanto/utils/$require';
 
 const USDC = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48' as const;
 

package/{docs/ai → skills/dequanto}/examples/deploy-contract.spec.ts

@@ -1,8 +1,8 @@
-import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
-import { Deployments } from '@dequanto/contracts/deploy/Deployments';
-import { Generator } from '@dequanto/gen/Generator';
-import { $account } from '@dequanto/utils/$account';
-import { $require } from '@dequanto/utils/$require';
+import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
+import { Deployments } from 'dequanto/contracts/deploy/Deployments';
+import { Generator } from 'dequanto/gen/Generator';
+import { $account } from 'dequanto/utils/$account';
+import { $require } from 'dequanto/utils/$require';
 import { File } from 'atma-io';
 
 // In a Hardhat project, include the @0xweb/hardhat plugin in hardhat.config.*.

package/{docs/ai → skills/dequanto}/examples/erc4337-userop.spec.ts

@@ -1,10 +1,10 @@
-import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
-import { BlockchainExplorerFactory } from '@dequanto/explorer/BlockchainExplorerFactory';
-import { Erc4337Service } from '@dequanto/erc4337/Erc4337Service';
-import { UserOperation } from '@dequanto/erc4337/models/UserOperation';
-import { $address } from '@dequanto/utils/$address';
-import { $erc4337 } from '@dequanto/erc4337/utils/$erc4337';
-import { $require } from '@dequanto/utils/$require';
+import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
+import { BlockchainExplorerFactory } from 'dequanto/explorer/BlockchainExplorerFactory';
+import { Erc4337Service } from 'dequanto/erc4337/Erc4337Service';
+import { UserOperation } from 'dequanto/erc4337/models/UserOperation';
+import { $address } from 'dequanto/utils/$address';
+import { $erc4337 } from 'dequanto/erc4337/utils/$erc4337';
+import { $require } from 'dequanto/utils/$require';
 
 UTest({
     async 'hash a UserOperation and create an ERC-4337 service' () {

package/{docs/ai → skills/dequanto}/examples/explorer-abi.spec.ts

@@ -1,6 +1,6 @@
-import { BlockchainExplorerFactory } from '@dequanto/explorer/BlockchainExplorerFactory';
-import { $address } from '@dequanto/utils/$address';
-import { $require } from '@dequanto/utils/$require';
+import { BlockchainExplorerFactory } from 'dequanto/explorer/BlockchainExplorerFactory';
+import { $address } from 'dequanto/utils/$address';
+import { $require } from 'dequanto/utils/$require';
 
 UTest({
     async 'fetch stable USDC ABI and source from configured Ethereum explorer' () {

package/{docs/ai → skills/dequanto}/examples/generate-contract-class.spec.ts

@@ -1,5 +1,5 @@
-import { Generator } from '@dequanto/gen/Generator';
-import { $require } from '@dequanto/utils/$require';
+import { Generator } from 'dequanto/gen/Generator';
+import { $require } from 'dequanto/utils/$require';
 import { File } from 'atma-io';
 
 // Generator is the low-level API for creating contract classes programmatically.

package/skills/dequanto/examples/hardhat-debug.spec.ts

@@ -0,0 +1,29 @@
+import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
+import { $require } from 'dequanto/utils/$require';
+
+UTest({
+    async 'change balances, storage, and time on Hardhat and roll back'() {
+        const client = await Web3ClientFactory.getAsync('hh:memory');
+        const address = '0x0000000000000000000000000000000000001234';
+        const balanceBefore = await client.getBalance(address);
+        const storageBefore = await client.getStorageAt(address, 0);
+        const blockBefore = await client.getBlockNumber();
+        const id = await client.debug.snapshot();
+
+        await client.debug.setBalance(address, 10n ** 18n);
+        $require.eq(await client.getBalance(address), 10n ** 18n);
+
+        // The same operation writes a known slot at any contract address.
+        await client.debug.setStorageAt(address, 0, '0x2a');
+        $require.eq(BigInt(await client.getStorageAt(address, 0)), 42n);
+
+        await client.debug.mine('5days');
+        $require.eq(await client.getBlockNumber(), blockBefore + 432_000);
+
+        await client.debug.revert(id);
+
+        $require.eq(await client.getBalance(address), balanceBefore);
+        $require.eq(await client.getStorageAt(address, 0), storageBefore);
+        $require.eq(await client.getBlockNumber(), blockBefore);
+    }
+});

package/skills/dequanto/examples/hardhat-fork.spec.ts

@@ -0,0 +1,31 @@
+import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
+import { ERC20 } from 'dequanto/prebuilt/openzeppelin/ERC20';
+import { $erc20 } from 'dequanto/utils/$erc20';
+import { $require } from 'dequanto/utils/$require';
+
+UTest({
+    async 'set an ERC20 balance and transfer from an impersonated account on a fork' () {
+        // Requires an accessible Ethereum RPC from the dequanto configuration.
+        const client = await Web3ClientFactory.getAsync('hh:memory:eth');
+        // To use an already running local Ethereum fork, use getAsync('hh:eth').
+        const usdc = new ERC20('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', client);
+        const account = {
+            address: '0x0000000000000000000000000000000000001234',
+            type: 'impersonated'
+        } as const;
+        const to = '0x0000000000000000000000000000000000005678';
+        const amount = 1_000_000n; // 1 USDC (6 decimals).
+
+
+        await client.debug.setBalance(account.address, 10n ** 18n);
+        await $erc20.setBalanceAny(client, usdc.address, account.address, amount);
+        $require.eq(await usdc.balanceOf(account.address), amount);
+
+        const recipientBalance = await usdc.balanceOf(to);
+        const writer = await usdc.$receipt().transfer(account, to, amount);
+
+        $require.Hex(writer.receipt.transactionHash);
+        $require.eq(await usdc.balanceOf(account.address), 0n);
+        $require.eq(await usdc.balanceOf(to), recipientBalance + amount);
+    }
+});

package/{docs/ai → skills/dequanto}/examples/index-events.spec.ts

@@ -1,7 +1,7 @@
-import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
-import { EventsIndexer } from '@dequanto/indexer/EventsIndexer';
-import { ERC20 } from '@dequanto/prebuilt/openzeppelin/ERC20';
-import { $require } from '@dequanto/utils/$require';
+import { Web3ClientFactory } from 'dequanto/clients/Web3ClientFactory';
+import { EventsIndexer } from 'dequanto/indexer/EventsIndexer';
+import { ERC20 } from 'dequanto/prebuilt/openzeppelin/ERC20';
+import { $require } from 'dequanto/utils/$require';
 
 UTest({
     async 'index stable USDC Transfer logs from live Ethereum RPC' () {