dequanto 0.2.49 → 0.2.51

package/src/rpc/RpcContract.ts

@@ -2,11 +2,12 @@ import di from 'a-di';
 import alot from 'alot';
 import { Rpc, RpcTypes } from './Rpc';
 
-import { TAbiItem, TAbiOutput } from '@dequanto/types/TAbi';
+import { TAbiItem } from '@dequanto/types/TAbi';
 import { TAddress } from '@dequanto/models/TAddress';
 import { $require } from '@dequanto/utils/$require';
 import { $abiUtils } from '@dequanto/utils/$abiUtils';
 import { $abiCoder } from '@dequanto/abi/$abiCoder';
+import { $abi } from '@dequanto/abi/$abi';
 import { RpcError } from './RpcError';
 import { $hex } from '@dequanto/utils/$hex';
 import { TEth } from '@dequanto/models/TEth';
@@ -54,7 +55,7 @@ export class RpcContract {
             if (methodAbi == null) {
                 return hex;
             }
-            return utils.deserializeOutput(hex, methodAbi.outputs);
+            return $abi.decodeReturn(methodAbi, hex);
         } catch (err) {
             if (err instanceof RpcError) {
                 err.message = `RpcCall ${req.method} (${JSON.stringify(req.params)}) ${err.message}`;
@@ -82,7 +83,7 @@ export class RpcContract {
                     let defaults = null;
                     try {
                         const defaultHex = $abiCoder.encode(returnABI, [null]);
-                        defaults = utils.deserializeOutput(defaultHex, returnABI);
+                        defaults = $abi.decodeReturn(abi, defaultHex);
                     } catch (error) {}
                     return {
                         defaults,
@@ -90,7 +91,7 @@ export class RpcContract {
                     };
                 }
                 let hex = typeof resp === 'string' ? resp : resp.data;
-                let result = utils.deserializeOutput(hex, returnABI);
+                let result = $abi.decodeReturn(abi, hex);
                 return result;
             });
 
@@ -191,32 +192,3 @@ export class RpcContract {
     // }
 }
 
-
-namespace utils {
-    export function deserializeOutput(hex: string, outputs: TAbiOutput[]) {
-
-        let abi = outputs;
-        let isDynamic: boolean = null;
-        if (outputs.length > 1) {
-            let isNamedTuple = outputs.every(x => x.name != null && x.name !== '');
-            if (isNamedTuple) {
-                // Return as an object
-                abi = [ { type: 'tuple', components: outputs, name: null } ];
-                isDynamic = false;
-            }
-        }
-
-        try {
-            let arr = $abiCoder.decode(abi as any, hex, {
-                dynamic: isDynamic
-            });
-            let value = abi.length === 1 ? arr[0] : arr;
-            return value;
-        } catch (error) {
-            if (outputs.length === 1 && abi.length === 1) {
-                return $abiCoder.decodeSingle(abi[0], hex);
-            }
-            throw error;
-        }
-    }
-}

package/src/utils/$account.ts

@@ -1,6 +1,7 @@
 import { EoAccount, Erc4337Account, SafeAccount, TAccount, TimelockAccount } from "@dequanto/models/TAccount";
 import { $address } from './$address';
 import { $require } from './$require';
+import { $sig } from './$sig';
 
 export namespace $account {
 
@@ -64,4 +65,8 @@ export namespace $account {
         // Optimistic match by pattern "timelock/";
         return rgx.test(account.name);
     }
+
+    export function generate(name: string): EoAccount {
+        return $sig.$account.generate({ name });
+    }
 }

package/src/utils/$config.ts

@@ -16,8 +16,8 @@ export namespace $config {
     let envOptions = null;
 
     export function get <T = any> (path: string, $default?: T): T {
-        let value = (typeof $global.app !== 'undefined' ? $global.app.config?.$get?.(path) : null)
-            ?? obj_getProperty(config, path)
+        let value = obj_getProperty(config, path)
+            ?? (typeof $global.app !== 'undefined' ? $global.app.config?.$get?.(path) : null)
             ?? obj_getProperty(envOptions, path);
 
         if (value == null && envOptions == null) {
@@ -79,11 +79,10 @@ export namespace $config {
         let explorer = $config.get<IConfigData['blockchainExplorer']>(`blockchainExplorer`);
         let chains = $config.get<IConfigData['chains']>('chains', []);
 
-
         let explorerConfig = explorer[platform];
         let chainConfig = chains.find(x => x.platform === platform || x.aliases?.includes(platform));
 
-        $require.notNull(explorerConfig || chainConfig, `Unsupported platform ${platform} for web3 client`);
+        $require.notNull(explorerConfig || chainConfig, `Unsupported platform ${platform} for blockchain explorer`);
         return {
             platform,
             ...(chainConfig?.explorers?.[0] ?? {}),
@@ -92,11 +91,10 @@ export namespace $config {
     }
 
     export function set <T = any> (path: string, value: T) {
+        obj_setProperty(config, path, value);
         if (typeof $global.app?.config?.$set === 'function') {
             $global.app.config.$set(path, value);
-            return;
         }
-        obj_setProperty(config, path, value);
     }
 
     /**

package/src/utils/$erc20.ts

@@ -0,0 +1,53 @@
+import alot from 'alot';
+import { $require } from './$require';
+import { $hex } from './$hex';
+import { $bigint } from './$bigint';
+import { TEth } from '@dequanto/models/TEth';
+import { Web3Client } from '@dequanto/clients/Web3Client';
+import { ERC20 } from '@dequanto/prebuilt/openzeppelin/ERC20';
+
+export namespace $erc20 {
+    export async function setBalanceAny(client: Web3Client, token: TEth.Address, account: TEth.Address, amount: bigint | number) {
+        $require.eq(client.platform, 'hardhat', `Set Balance available only on Hardhat/Forked network`);
+        const erc20 = new ERC20(token, client);
+        const rpc = await client.getRpc();
+
+        const req = await (erc20.$data() as any).balanceOf(account);
+        const balanceTrace = await rpc.request({
+            method: 'debug_traceCall',
+            params: [
+                req,
+                'latest',
+                {
+                    disableMemory: true,
+                    disableStack: true,
+                    disableStorage: false,
+                }
+            ]
+        }) as {
+            returnValue: TEth.Hex
+            failed: boolean
+            structLogs: {
+                "op": "RETURN",
+                "pc": 1698,
+                "storage": Record<string, TEth.Hex>
+            }[]
+        };
+
+        $require.True(balanceTrace.failed === false, `erc20 balance retrieval failed for ${await erc20.symbol()}`);
+        let returnOp = alot(balanceTrace.structLogs.reverse()).find(x => x.op === 'RETURN');
+        $require.notNull(returnOp, `RETURN opcode not found`);
+        $require.notNull(returnOp.storage, `Storage not found`);
+
+        let returnValue = $hex.raw(balanceTrace.returnValue);
+        let slots = alot.fromObject(returnOp.storage).filter(x => x.value === returnValue).toArray();
+        $require.gt(slots.length, 0, `Slot not found`);
+        let SLOT = $hex.ensure(slots[slots.length - 1].key);
+
+        let balance = typeof amount === 'number'
+            ? await $bigint.toWei(amount, await erc20.decimals())
+            : amount;
+
+        await client.debug.setStorageAt(erc20.address, SLOT, $bigint.toHex(balance));
+    }
+}

package/src/utils/$require.ts

@@ -61,17 +61,17 @@ export namespace $require {
         }
         return val;
     }
-    export function notNull<T> (val: T, message: string, ...logs): NonNullable<T> {
+    export function notNull<T> (val: T, message?: string, ...logs): NonNullable<T> {
         if (val == null) {
             logs?.forEach(log => console.error(log));
-            throw new Error(`Value is undefined. ${message}`);
+            throw new Error(`Value is undefined. ${message ?? ''}`);
         }
         return val;
     }
-    export function Null<T> (val: T, message: string, ...logs): T {
+    export function Null<T> (val: T, message?: string, ...logs): T {
         if (val != null) {
             logs?.forEach(log => console.error(log));
-            throw new Error(`Value ${val} expects to be undefined. ${message}`);
+            throw new Error(`Value ${val} expects to be undefined. ${message ?? ''}`);
         }
         return val;
     }

package/tsconfig.json

@@ -1,13 +1,13 @@
 {
     "exclude": [
-        "exports/core.lib.ts"
+        "exports/core.lib.ts",
+        "ts-temp"
     ],
     "compilerOptions": {
         "baseUrl": "./",
         "paths": {
             "@dequanto/*": [ "src/*" ],
-            "dequanto/*": [ "src/*" ],
-            "@dequanto-contracts/*": [ "src/prebuilt/*" ]
+            "dequanto/*": [ "src/*" ]
         },
         "typeRoots": [
             "node_modules/@types",

package/tsconfig.umd.json

@@ -6,8 +6,7 @@
     "compilerOptions": {
         "baseUrl": "./",
         "paths": {
-            "@dequanto/*": [ "src/*" ],
-            "@dequanto-contracts/*": [ "src/prebuilt/*" ]
+            "@dequanto/*": [ "src/*" ]
         },
         "lib": [ "ES2019", "dom" ],
         "typeRoots": [

package/docs/ai/examples/contract-read.spec.ts

@@ -1,44 +0,0 @@
-import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
-// dequanto ships prebuilt TypeScript clients for all OpenZeppelin contracts.
-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';
-
-const USDC = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48' as const;
-
-UTest({
-    async 'read stable USDC metadata from live Ethereum RPC' () {
-        const client = await Web3ClientFactory.getAsync('eth');
-        const usdc = new ERC20(USDC, client);
-
-        const [symbol, decimals, balance] = await Promise.all([
-            usdc.symbol(),
-            usdc.decimals(),
-            usdc.balanceOf('0x0000000000000000000000000000000000000000')
-        ]);
-
-        eq_(symbol, 'USDC');
-        eq_(Number(decimals), 6);
-        gte_(balance, 0n);
-    },
-
-    async 'read generated Aave Pool data from live Ethereum RPC' () {
-        const client = await Web3ClientFactory.getAsync('eth');
-        const pool = new AavePool(undefined, client);
-
-        const [addressesProvider, maxReserves, reserves, reserveData] = await Promise.all([
-            pool.ADDRESSES_PROVIDER(),
-            pool.MAX_NUMBER_RESERVES(),
-            pool.getReservesList(),
-            pool.getReserveData(USDC)
-        ]);
-
-        has_(addressesProvider, /^0x[a-fA-F0-9]{40}$/);
-        gt_(Number(maxReserves), 0);
-        eq_(reserves.some(x => x.toLowerCase() === USDC.toLowerCase()), true);
-        has_(reserveData.aTokenAddress, /^0x[a-fA-F0-9]{40}$/);
-        has_(reserveData.variableDebtTokenAddress, /^0x[a-fA-F0-9]{40}$/);
-        gte_(reserveData.liquidityIndex, 1n);
-    }
-});

package/docs/ai/examples/contract-write.spec.ts

@@ -1,16 +0,0 @@
-import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
-import { ERC20 } from '@dequanto-contracts/openzeppelin/ERC20';
-
-UTest({
-    async 'build ERC20 transfer tx data without submitting' () {
-        const client = await Web3ClientFactory.getAsync('eth');
-        const usdc = new ERC20('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', client);
-        const sender = { address: '0x0000000000000000000000000000000000000001' as const };
-        const receiver = '0x0000000000000000000000000000000000000002' as const;
-
-        const tx = await usdc.$data().transfer(sender, receiver, 1_000_000n);
-
-        eq_(tx.to.toLowerCase(), usdc.address.toLowerCase());
-        has_(tx.data, /^0xa9059cbb/);
-    }
-});

package/docs/ai/examples/deploy-contract.spec.ts

@@ -1,32 +0,0 @@
-import { Deployments } from '@dequanto/contracts/deploy/Deployments';
-import { Generator } from '@dequanto/gen/Generator';
-import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
-import { File } from 'atma-io';
-
-declare const include: any;
-
-UTest({
-    async 'deploy a generated contract with Deployments.ensure' () {
-        const hh = new HardhatProvider();
-        const client = hh.client();
-        const deployer = hh.deployer(0);
-        const deploymentsFile = './test/tmp/ai-examples/deployments-hardhat.json';
-
-        await File.removeAsync(deploymentsFile);
-
-        const generated = await Generator.generateFromSol('./test/fixtures/deployments/DeploymentsFoo.sol');
-        const module = await include.instance().js(generated.main);
-        const Ctor = module.DeploymentsFoo.DeploymentsFoo;
-
-        const deployments = new Deployments(client, deployer, {
-            directory: './test/tmp/ai-examples/',
-            verification: false
-        });
-
-        const { contract } = await deployments.ensure(Ctor, { arguments: [] });
-        const value = await (contract as any).getValue();
-
-        has_(contract.address, /^0x[a-fA-F0-9]{40}$/);
-        eq_(value, 4n);
-    }
-});

package/docs/ai/examples/explorer-abi.spec.ts

@@ -1,18 +0,0 @@
-import { BlockchainExplorerFactory } from '@dequanto/explorer/BlockchainExplorerFactory';
-
-UTest({
-    async 'fetch stable USDC ABI and source from configured Ethereum explorer' () {
-        const explorer = await BlockchainExplorerFactory.getAsync('eth');
-        const address = '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48';
-
-        const { abi, implementation } = await explorer.getContractAbi(address);
-        const source = await explorer.getContractSource(implementation);
-        const creation = await explorer.getContractCreation(address);
-
-        eq_(implementation.toLowerCase(), address);
-        gt_(JSON.parse(abi).length, 0);
-        has_(source.ContractName, /FiatToken|Proxy|USDC/i);
-        has_(creation.creator, /^0x[a-fA-F0-9]{40}$/);
-        has_(creation.txHash, /^0x[a-fA-F0-9]{64}$/);
-    }
-});

package/docs/ai/examples/rpc-read.spec.ts

@@ -1,15 +0,0 @@
-import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
-
-UTest({
-    async 'read latest block and zero-address balance from live Ethereum RPC' () {
-        const client = await Web3ClientFactory.getAsync('eth');
-
-        const latest = await client.getBlockNumber();
-        const block = await client.getBlock('latest');
-        const balance = await client.getBalance('0x0000000000000000000000000000000000000000');
-
-        gt_(Number(latest), 0);
-        gt_(Number(block.timestamp), 0);
-        gte_(balance, 0n);
-    }
-});

package/docs/ai/examples/send-transaction.spec.ts

@@ -1,22 +0,0 @@
-import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
-import { TxDataBuilder } from '@dequanto/txs/TxDataBuilder';
-
-UTest({
-    async 'build native transfer tx data with gas fields' () {
-        const client = await Web3ClientFactory.getAsync('eth');
-        const sender = { address: '0x0000000000000000000000000000000000000001' as const };
-        const receiver = '0x0000000000000000000000000000000000000002' as const;
-
-        const builder = new TxDataBuilder(client, sender, {
-            to: receiver
-        });
-
-        builder.setValue(10n ** 16n);
-        await builder.setGas({ gasEstimation: false, gasLimit: 21_000 });
-
-        eq_(builder.data.to, receiver);
-        eq_(builder.data.value, '0x2386f26fc10000');
-        eq_(Number(builder.data.gas), 21_000);
-        notEq_(builder.data.maxFeePerGas ?? builder.data.gasPrice, null);
-    }
-});

package/docs/ai/examples/storage-read.spec.ts

@@ -1,27 +0,0 @@
-import { HardhatProvider } from '@dequanto/hardhat/HardhatProvider';
-import { SlotsParser } from '@dequanto/solidity/SlotsParser';
-import { SlotsStorage } from '@dequanto/solidity/SlotsStorage';
-
-UTest({
-    async 'read Solidity storage with SlotsParser and SlotsStorage' () {
-        const code = `
-            contract Vault {
-                uint256 public count = 123;
-                mapping(address => uint256) balances;
-
-                constructor () {
-                    balances[address(0x1000000000000000000000000000000000000001)] = 7;
-                }
-            }
-        `;
-        const provider = new HardhatProvider();
-        const client = provider.client();
-        const { contract } = await provider.deployCode(code, { client });
-
-        const slots = await SlotsParser.slots({ path: '', code }, 'Vault');
-        const storage = SlotsStorage.createWithClient(client, contract.address, slots);
-
-        eq_(await storage.get('count'), 123n);
-        eq_(await storage.get('balances["0x1000000000000000000000000000000000000001"]'), 7n);
-    }
-});

package/docs/ai/examples/token-transfer.spec.ts

@@ -1,22 +0,0 @@
-import { Web3ClientFactory } from '@dequanto/clients/Web3ClientFactory';
-import { TokenTransferService } from '@dequanto/tokens/TokenTransferService';
-import { TokensService } from '@dequanto/tokens/TokensService';
-
-UTest({
-    async 'load known token metadata and read a live token balance' () {
-        const client = await Web3ClientFactory.getAsync('eth');
-        const tokens = new TokensService('eth');
-        const usdc = await tokens.getKnownToken('USDC');
-        const service = new TokenTransferService(client);
-
-        const balance = await service.getBalance(
-            '0x0000000000000000000000000000000000000000',
-            usdc
-        );
-
-        eq_(usdc.symbol, 'USDC');
-        eq_(usdc.decimals, 6);
-        eq_(usdc.address.toLowerCase(), '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48');
-        gte_(balance, 0n);
-    }
-});

package/docs/ai/references/storage.md

@@ -1,93 +0,0 @@
-# Solidity Storage
-
-Use `SlotsParser` to derive layout and `SlotsStorage` to read or write slots. Do not decode raw storage words as ABI payloads.
-
-Key source files:
-
-- `src/solidity/SlotsParser.ts`
-- `src/solidity/SlotsStorage.ts`
-- `src/solidity/storage/handlers/SlotStructHandler.ts`
-- `src/solidity/storage/handlers/SlotMappingHandler.ts`
-- `src/solidity/storage/handlers/SlotDynamicArrayHandler.ts`
-- `src/solidity/storage/SlotsStorageTransport.ts`
-- `src/gen/GeneratorStorageReader.ts`
-
-Useful tests:
-
-- `test/solidity/SlotsReader.spec.ts`
-- `test/solidity/Storage.spec.ts`
-- `test/solidity/SlotsParser.spec.ts`
-- `test/generate/slotreader.spec.ts`
-
-## Parse Slots From Solidity
-
-```ts
-import { SlotsParser } from '@dequanto/solidity/SlotsParser';
-
-const slots = await SlotsParser.slots({
-    path: './contracts/Vault.sol'
-}, 'Vault');
-```
-
-For inline code:
-
-```ts
-const slots = await SlotsParser.slots({ path: '', code }, 'Foo');
-```
-
-## Parse Slots From ABI Inputs
-
-Use this for standalone struct or tuple ABI data:
-
-```ts
-const slots = await SlotsParser.slotsFromAbi(
-    '(uint256 foo, address owner, bool enabled)'
-);
-```
-
-## Read Contract Storage
-
-```ts
-import { SlotsStorage } from '@dequanto/solidity/SlotsStorage';
-
-const storage = SlotsStorage.createWithClient(client, contract.address, slots);
-
-const owner = await storage.get('owner');
-const user = await storage.get('users[0]');
-const balance = await storage.get(`balances["${account}"]`);
-```
-
-Supported path forms include:
-
-- `field`
-- `struct.field`
-- `array[0]`
-- `mapping["0x..."]`
-- `mapping["0x..."].field`
-- `nested[0].balances[1]`
-- breadcrumb arrays such as `['users', account, 'balance']`
-
-## Read Diamond Or Offset Storage
-
-For library-selected storage roots:
-
-```ts
-const storage = SlotsStorage.createWithClient(client, contract.address, slots, {
-    storageOffset: $contract.keccak256('diamond.app.storage')
-});
-```
-
-## Write Storage In Tests
-
-`SlotsStorage.set(...)` exists and is useful in Hardhat/debug contexts:
-
-```ts
-await storage.set('user.balance', 1000n);
-```
-
-Do not use storage writes in production code unless the transport explicitly supports it and the task requires test/debug mutation.
-
-## Raw Slot Reads
-
-Use `client.getStorageAt(address, slot)` or `client.getStorageAtBatched(address, slots)` only when raw words are needed.
-

package/docs/ai/skill/dequanto/SKILL.md

@@ -1,59 +0,0 @@
----
-name: dequanto
-description: Use when implementing EVM, blockchain, smart-contract, token, RPC, event-indexing, Safe, ERC-4337, storage, deployment, or ABI work in TypeScript projects that use the dequanto framework. Prefer dequanto APIs over ethers, viem, web3.js, raw JSON-RPC, manual explorer HTTP calls, or hand-written ABI encoding unless the user explicitly asks otherwise.
----
-
-# Dequanto
-
-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.
-6. After TypeScript edits in the dequanto repo, run `npm run typecheck -- --pretty false`.
-
-## Defaults
-
-- Use `await Web3ClientFactory.getAsync(platform)` for chain clients so configuration is loaded before RPC, explorer, and chain services are used.
-- Use generated contract classes for ABI calls and transactions: call read-only ABI methods directly as normal TypeScript methods, and call writable ABI methods through `contract.$receipt().someFunction(sender, ...args)`.
-- Use generated `$data()` for calldata.
-- Treat `$receipt()` as a completed `TxWriter` flow that waits for the transaction receipt. The first writable-method argument is an `IAccount`.
-- Read account shapes in `src/models/TAccount.ts` when composing transaction senders:
-    - EOA with only `address`: the RPC provider/node is responsible for signing.
-    - EOA with `key`: dequanto signs directly; encrypted `p1:0x...` keys require the PIN from environment configuration.
-    - `safe`: wrap calldata into a Gnosis Safe transaction. Provide `address` and an `operator`; if enough owners/signers are available, dequanto signs and submits on-chain, otherwise it submits to the Gnosis Safe service for later signing.
-    - `timelock`: wrap calldata into an OpenZeppelin Timelock transaction and submit it via `operator`.
-    - `erc4337`: wrap calldata into an ERC-4337 user operation and submit it via `operator`.
-- 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.
-- 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`.
-
-## Reference Routing
-
-- Contract reads, writes, generated helper facets: `../../references/contracts.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`
-- 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`
-
-## Rules
-
-- Never guess a dequanto API signature.
-- Inspect generated contract classes before using generated method names or event helper names.
-- Do not add ethers, viem, web3.js, or external Safe/account-abstraction SDKs when dequanto already has a suitable API.
-- Keep code version-specific to the installed dequanto package.
-- Prefer examples that compile in the target project over abstract snippets.
-