crypto-aio 0.0.2 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-10-01
+
+### Added
+
+- initial release 🎉​🎊​.
+
+[Unreleased]: https://github.com/vhidvz/crypto-aio/compare/0.1.0...HEAD
+[0.1.0]: https://github.com/vhidvz/crypto-aio/releases/tag/0.1.0

package/README.md

@@ -1,25 +1,155 @@
-# Crypto-AIO
+# crypto-aio
 
-All-In-One Crypto-Currency for Backend
-
-[![Build, Test and Publish](https://github.com/vhidvz/crypto-aio/actions/workflows/npm-ci.yml/badge.svg)](https://github.com/vhidvz/crypto-aio/actions/workflows/npm-ci.yml)
 [![npm](https://img.shields.io/npm/v/crypto-aio)](https://www.npmjs.com/package/crypto-aio)
+[![CI](https://github.com/vhidvz/crypto-aio/actions/workflows/ci.yml/badge.svg)](https://github.com/vhidvz/crypto-aio/actions/workflows/ci.yml)
 ![npm](https://img.shields.io/npm/dm/crypto-aio)
-[![Coverage](https://raw.githubusercontent.com/vhidvz/crypto-aio/main/docs/coverage.svg)](https://htmlpreview.github.io/?https://github.com/vhidvz/crypto-aio/blob/main/docs/coverage/lcov-report/index.html)
-[![GitHub](https://img.shields.io/github/license/vhidvz/crypto-aio?style=flat)](https://github.com/vhidvz/crypto-aio/blob/master/LICENSE)
-[![documentation](https://img.shields.io/badge/documentation-click_to_read-c27cf4)](https://vhidvz.github.io/crypto-aio/)
+[![Coverage](https://raw.githubusercontent.com/vhidvz/crypto-aio/main/coverage-badge.svg)](https://htmlpreview.github.io/?https://github.com/vhidvz/crypto-aio/blob/main/coverage/lcov-report/index.html)
+[![License](https://img.shields.io/github/license/vhidvz/crypto-aio?style=flat)](LICENSE)
+[![documentation](https://img.shields.io/badge/documentation-read_the_docs-c27cf4)](https://vhidvz.github.io/crypto-aio/)
+
+**One TypeScript API for moving money on blockchains.** Balances, transfers, confirmations
+and deposit scanning across EVM chains, Bitcoin, Tron, Solana, TON and the Avalanche X-Chain and
+P-Chain, built for exchanges, wallets and payment systems.
+
+[Documentation](https://vhidvz.github.io/crypto-aio/) ·
+[Quick start](https://vhidvz.github.io/crypto-aio/start/quick-start.html) ·
+[Learn from zero](https://vhidvz.github.io/crypto-aio/learn/) ·
+[Examples](https://vhidvz.github.io/crypto-aio/build/examples.html) ·
+[API](https://vhidvz.github.io/crypto-aio/reference/api.html)
+
+## Why crypto-aio
+
+Every chain has an SDK that can build, sign and send a transaction. None of them is a payment
+system. The hard part of moving money is everything around the transaction: a reply that never
+arrives, a process that dies between signing and sending, two servers sending from one wallet, a
+node that says "final" about a block that is later replaced. crypto-aio is the layer that handles
+those cases, written once, with the same API on every chain:
+
+- **Pay exactly once.** Every transfer carries your own idempotency key. Repeat the call after a
+  timeout, a crash or a lost reply, and you get the same payment back, never a second one.
+- **Crash-safe.** A signed transaction is stored before it is sent. After a restart, the library
+  sends those exact bytes again; recovery never signs.
+- **Final means proven.** A transfer is final only on finalized chain data that a quorum of
+  independent endpoints agree on, never on one node's word.
+- **Deposits that survive reorgs.** Durable scanners deliver every block at least once, and roll
+  back when the chain reorganizes.
+- **Keys stay with signers.** In memory, or behind your HSM, KMS or MPC custody, with a policy
+  hook before every signature. Logs, errors and events never carry a secret.
+- **One shape, explicit differences.** What a chain cannot do is a named capability, not a silent
+  difference.
+
+**Who it is for:** backend developers building exchanges, custodial wallets, payment processors
+and treasury systems on Node.js. New to crypto? The documentation teaches everything from first
+principles, starting with [what a ledger is](https://vhidvz.github.io/crypto-aio/learn/foundations/ledgers.html).
+
+## Supported networks
+
+| Family | Chains | Through |
+| --- | --- | --- |
+| EVM | Ethereum, BNB Smart Chain, Polygon, Avalanche C-Chain, Arbitrum, Optimism, Base, and any EVM chain you add | `ethers` 6 (default) or `web3` 4 |
+| Bitcoin | mainnet, testnet, testnet4, signet, regtest | `bitcoinjs-lib` 7 and an Esplora indexer |
+| Tron | mainnet, Shasta, Nile | `tronweb` 6 |
+| Solana | mainnet, devnet, testnet | `@solana/web3.js` 1 |
+| TON | mainnet, testnet | `@ton/ton` 16 and toncenter |
+| Avalanche X-Chain and P-Chain | mainnet, Fuji | `@avalabs/avalanchejs` 5 and the Avalanche Data API |
+
+What each network supports, family by family, is in
+[Networks](https://vhidvz.github.io/crypto-aio/reference/networks/).
+
+## Install
+
+crypto-aio needs Node.js 22 or later (Solana: 22.12 or later). Install the package, and only the
+SDK of each family you use:
+
+```sh
+npm install crypto-aio ethers           # EVM chains (or web3)
+npm install crypto-aio bitcoinjs-lib    # Bitcoin
+npm install crypto-aio tronweb          # Tron
+npm install crypto-aio @solana/web3.js  # Solana
+npm install crypto-aio @ton/ton @ton/core @ton/crypto  # TON
+npm install crypto-aio @avalabs/avalanchejs  # Avalanche X-Chain and P-Chain
+```
+
+A handle whose SDK is missing fails with `DEPENDENCY_MISSING` and names the install command.
 
-## Quick Start
+## Your first transfer, with no network and no keys
 
+`crypto-aio/testing` ships an in-memory chain, so you can see the whole flow before you configure
+anything:
+
+<!-- runnable -->
 ```ts
-import { CryptoAio } from 'crypto-aio';
+import { createFakeEnv } from 'crypto-aio/testing';
+
+const env = await createFakeEnv(); // an in-memory chain, a funded wallet, and a handle
+const sub = await env.run(
+  env.bc.transfer({ to: env.stranger(), amount: '0.001' }, { idempotencyKey: 'order-42' }),
+);
+env.chain.mine(4); // the fake chain makes blocks when you ask
+const { status } = await env.run(sub.wait({ finality: 'final' }));
+console.log(status.state, status.evidence); // final proven
+```
+
+The [Quick start](https://vhidvz.github.io/crypto-aio/start/quick-start.html) explains each line.
 
-const caio = new CryptoAio();
+## On a real network
 
-caio.eth.getGasPrice();
+```ts
+import { Blockchain, configure, localSigner, secret } from 'crypto-aio';
+
+configure({
+  providers: {
+    alchemy: { preset: 'alchemy', apiKey: secret(process.env.ALCHEMY_KEY ?? '') },
+    infura: { preset: 'infura', apiKey: secret(process.env.INFURA_KEY ?? '') },
+  },
+  signers: { hot: localSigner({ id: 'hot', secp256k1: secret(process.env.HOT_KEY ?? '') }) },
+  wallets: { treasury: { signer: 'hot' } },
+  chains: { ethereum: { network: 'sepolia', provider: ['alchemy', 'infura'], wallet: 'treasury' } },
+  lifecycle: { requireIdempotencyKey: true },
+});
 
-caio.eth.createAccount();
-caio.eth.account.create();
+const eth = Blockchain.create({ chain: 'ethereum' });
+const me = await eth.walletAddress();
+console.log((await eth.getBalance(me.canonical)).amount.format()); // e.g. '0.5 ETH'
 
-caio.eth.account.getBalance();
+const sub = await eth.transfer(
+  { to: '0x3535353535353535353535353535353535353535', amount: '0.01' },
+  { idempotencyKey: 'withdrawal-42' }, // your own id: repeating the call never pays twice
+);
+const { status } = await sub.wait({ finality: 'final' });
+console.log(status.state, status.evidence); // 'final' 'proven'
 ```
+
+The same calls work on every chain above. [Connect to a real
+network](https://vhidvz.github.io/crypto-aio/build/connect.html) has the configuration for each
+family.
+
+## Where to go next
+
+| If you… | Start here |
+| --- | --- |
+| Are new to cryptocurrency or blockchains | The [learning path](https://vhidvz.github.io/crypto-aio/learn/): money, keys, transactions and finality, then the engineering of safe payments, then a tour of crypto-aio |
+| Know blockchains and want the model fast | [crypto-aio in 10 minutes](https://vhidvz.github.io/crypto-aio/start/mental-model.html), then the [hands-on tutorial](https://vhidvz.github.io/crypto-aio/start/tutorial.html) |
+| Want to build now | [Examples](https://vhidvz.github.io/crypto-aio/build/examples.html) and the [Build guides](https://vhidvz.github.io/crypto-aio/build/) |
+| Need an exact answer | [API](https://vhidvz.github.io/crypto-aio/reference/api.html), [Configuration](https://vhidvz.github.io/crypto-aio/reference/configuration.html), [Errors](https://vhidvz.github.io/crypto-aio/reference/errors.html) |
+| Are going to production | [Production architecture](https://vhidvz.github.io/crypto-aio/tour/production.html) and the [checklist](https://vhidvz.github.io/crypto-aio/build/production.html) |
+| Want to add a chain or a store | [Explore](https://vhidvz.github.io/crypto-aio/explore/): plugins, stores and the source map |
+
+## Status
+
+crypto-aio is at **0.1.0**, the first release of this API; the 0.0.x releases on npm are an older,
+unrelated API. Before 1.0, some extension interfaces may still change
+([what is stable](https://vhidvz.github.io/crypto-aio/reference/stability.html)). Only in-memory
+stores ship: production needs durable stores of your own, proven with the contract suites in
+`crypto-aio/testing`. Release notes are in the [changelog](CHANGELOG.md).
+
+## Contributing
+
+Issues and pull requests are welcome. `pnpm install` and `pnpm check` (lint, typecheck and tests)
+are all a change needs locally; the [source map](https://vhidvz.github.io/crypto-aio/explore/source-map.html)
+explains the repository, and [docs/README.md](docs/README.md) how the documentation is built and
+tested.
+
+## License
+
+[MIT](LICENSE)

package/dist/adapters/avalanche/address.d.ts

@@ -0,0 +1,15 @@
+import type { NormalizedAddress } from '../../core/model/address';
+import type { AvalancheNetworkConfig } from './network';
+export declare const ADDRESS_BYTES = 20;
+type AddressParams = Pick<AvalancheNetworkConfig, 'alias' | 'hrp'>;
+/** The 20 address bytes of a compressed secp256k1 public key. */
+export declare function addressBytesOf(publicKey: Uint8Array): Uint8Array;
+/** `X-avax1…`: the canonical form of 20 address bytes on this chain. */
+export declare function formatAddress(bytes: Uint8Array, params: AddressParams): string;
+/**
+ * The address bytes of `address`; throws `INVALID_ADDRESS` with a fixed text that never
+ * repeats the input, which may be a pasted secret.
+ */
+export declare function decodeAddress(address: string, params: AddressParams): Uint8Array;
+export declare function normalizeAddress(address: string, params: AddressParams): NormalizedAddress;
+export {};

package/dist/adapters/avalanche/address.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADDRESS_BYTES = void 0;
+exports.addressBytesOf = addressBytesOf;
+exports.formatAddress = formatAddress;
+exports.decodeAddress = decodeAddress;
+exports.normalizeAddress = normalizeAddress;
+/**
+ * X-Chain and P-Chain addresses (SDK-free). An address is 20 bytes, the RIPEMD-160 of the
+ * SHA-256 of a compressed secp256k1 public key, written in bech32 with the network's
+ * human-readable part (`avax`, `fuji`) behind the chain's alias: `X-avax1…`, `P-avax1…`.
+ * The canonical form carries the alias, lower case. A bare `avax1…` is accepted and
+ * normalized to this chain's alias; the other chain's alias (`P-` on the X-Chain), a
+ * C-Chain or another network's address, and anything that is not 20 bytes are refused: the
+ * same key's bytes on another chain are a cross-chain transfer, which a transfer never is.
+ */
+const ripemd160_1 = require("@noble/hashes/ripemd160");
+const sha256_1 = require("@noble/hashes/sha256");
+const base_1 = require("@scure/base");
+const error_1 = require("../../core/errors/error");
+exports.ADDRESS_BYTES = 20;
+/** Bech32 allows at most 90 characters; the alias and `-` add two. */
+const MAX_ADDRESS_LENGTH = 92;
+const invalid = (reason) => new error_1.ValidationError('INVALID_ADDRESS', `not an address of this chain: ${reason}`);
+/** The 20 address bytes of a compressed secp256k1 public key. */
+function addressBytesOf(publicKey) {
+    if (publicKey.length !== 33 || (publicKey[0] !== 2 && publicKey[0] !== 3)) {
+        throw new error_1.ValidationError('INVALID_ADDRESS', 'an Avalanche address needs a 33-byte compressed secp256k1 public key');
+    }
+    return (0, ripemd160_1.ripemd160)((0, sha256_1.sha256)(publicKey));
+}
+/** `X-avax1…`: the canonical form of 20 address bytes on this chain. */
+function formatAddress(bytes, params) {
+    return `${params.alias}-${base_1.bech32.encode(params.hrp, base_1.bech32.toWords(bytes))}`;
+}
+/**
+ * The address bytes of `address`; throws `INVALID_ADDRESS` with a fixed text that never
+ * repeats the input, which may be a pasted secret.
+ */
+function decodeAddress(address, params) {
+    if (typeof address !== 'string' || address.length > MAX_ADDRESS_LENGTH) {
+        throw invalid('malformed');
+    }
+    const dash = address.indexOf('-');
+    if (dash !== -1 && address.slice(0, dash) !== params.alias) {
+        throw invalid(`the chain alias is not '${params.alias}'`);
+    }
+    const body = dash === -1 ? address : address.slice(dash + 1);
+    let decoded;
+    try {
+        decoded = base_1.bech32.decode(body, 90);
+    }
+    catch {
+        throw invalid('malformed bech32');
+    }
+    if (decoded.prefix !== params.hrp) {
+        throw invalid(`the network prefix is not '${params.hrp}'`);
+    }
+    let bytes;
+    try {
+        bytes = base_1.bech32.fromWords(decoded.words);
+    }
+    catch {
+        throw invalid('malformed bech32');
+    }
+    if (bytes.length !== exports.ADDRESS_BYTES)
+        throw invalid('not 20 bytes');
+    return bytes;
+}
+function normalizeAddress(address, params) {
+    const canonical = formatAddress(decodeAddress(address, params), params);
+    return { canonical, display: canonical };
+}
+//# sourceMappingURL=address.js.map

package/dist/adapters/avalanche/address.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.js","sourceRoot":"","sources":["../../../src/adapters/avalanche/address.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * X-Chain and P-Chain addresses (SDK-free). An address is 20 bytes, the RIPEMD-160 of the\n * SHA-256 of a compressed secp256k1 public key, written in bech32 with the network's\n * human-readable part (`avax`, `fuji`) behind the chain's alias: `X-avax1…`, `P-avax1…`.\n * The canonical form carries the alias, lower case. A bare `avax1…` is accepted and\n * normalized to this chain's alias; the other chain's alias (`P-` on the X-Chain), a\n * C-Chain or another network's address, and anything that is not 20 bytes are refused: the\n * same key's bytes on another chain are a cross-chain transfer, which a transfer never is.\n */\nimport { ripemd160 } from '@noble/hashes/ripemd160';\nimport { sha256 } from '@noble/hashes/sha256';\nimport { bech32 } from '@scure/base';\nimport { ValidationError } from '../../core/errors/error';\nimport type { NormalizedAddress } from '../../core/model/address';\nimport type { AvalancheNetworkConfig } from './network';\n\nexport const ADDRESS_BYTES = 20;\n\n/** Bech32 allows at most 90 characters; the alias and `-` add two. */\nconst MAX_ADDRESS_LENGTH = 92;\n\ntype AddressParams = Pick<AvalancheNetworkConfig, 'alias' | 'hrp'>;\n\nconst invalid = (reason: string): ValidationError =>\n  new ValidationError('INVALID_ADDRESS', `not an address of this chain: ${reason}`);\n\n/** The 20 address bytes of a compressed secp256k1 public key. */\nexport function addressBytesOf(publicKey: Uint8Array): Uint8Array {\n  if (publicKey.length !== 33 || (publicKey[0] !== 2 && publicKey[0] !== 3)) {\n    throw new ValidationError(\n      'INVALID_ADDRESS',\n      'an Avalanche address needs a 33-byte compressed secp256k1 public key',\n    );\n  }\n  return ripemd160(sha256(publicKey));\n}\n\n/** `X-avax1…`: the canonical form of 20 address bytes on this chain. */\nexport function formatAddress(bytes: Uint8Array, params: AddressParams): string {\n  return `${params.alias}-${bech32.encode(params.hrp, bech32.toWords(bytes))}`;\n}\n\n/**\n * The address bytes of `address`; throws `INVALID_ADDRESS` with a fixed text that never\n * repeats the input, which may be a pasted secret.\n */\nexport function decodeAddress(address: string, params: AddressParams): Uint8Array {\n  if (typeof address !== 'string' || address.length > MAX_ADDRESS_LENGTH) {\n    throw invalid('malformed');\n  }\n  const dash = address.indexOf('-');\n  if (dash !== -1 && address.slice(0, dash) !== params.alias) {\n    throw invalid(`the chain alias is not '${params.alias}'`);\n  }\n  const body = dash === -1 ? address : address.slice(dash + 1);\n  let decoded: { prefix: string; words: number[] };\n  try {\n    decoded = bech32.decode(body as `${string}1${string}`, 90);\n  } catch {\n    throw invalid('malformed bech32');\n  }\n  if (decoded.prefix !== params.hrp) {\n    throw invalid(`the network prefix is not '${params.hrp}'`);\n  }\n  let bytes: Uint8Array;\n  try {\n    bytes = bech32.fromWords(decoded.words);\n  } catch {\n    throw invalid('malformed bech32');\n  }\n  if (bytes.length !== ADDRESS_BYTES) throw invalid('not 20 bytes');\n  return bytes;\n}\n\nexport function normalizeAddress(\n  address: string,\n  params: AddressParams,\n): NormalizedAddress {\n  const canonical = formatAddress(decodeAddress(address, params), params);\n  return { canonical, display: canonical };\n}\n"]}

package/dist/adapters/avalanche/api.d.ts

@@ -0,0 +1,100 @@
+import { ProviderError } from '../../core/errors/error';
+import type { Transport } from '../../core/transport/types';
+import type { AvalancheCallTags, AvalancheVm } from './types';
+/** A block as the node reports it; ids are CB58. */
+export interface NodeBlock {
+    readonly id: string;
+    readonly parentId: string;
+    readonly height: bigint;
+    /** Unix seconds; absent on P-Chain blocks from before the Banff upgrade. */
+    readonly timestamp?: number;
+    /** Every transaction the block carries, decision and proposal alike. */
+    readonly txIds: readonly string[];
+}
+/** The P-Chain's view of a transaction (`platform.getTxStatus`). */
+export type PlatformStatus = 'Committed' | 'Aborted' | 'Processing' | 'Dropped' | 'Unknown';
+export interface FeeState {
+    readonly capacity: bigint;
+    readonly excess: bigint;
+    readonly price: bigint;
+    readonly timestamp: string;
+}
+/** The P-Chain's fee dimensions' weights: bandwidth, reads, writes, compute. */
+export type FeeWeights = readonly [number, number, number, number];
+/** Where the indexer says a transaction is. */
+export interface Location {
+    readonly height: bigint;
+    readonly hash: string;
+}
+export declare const malformed: (what: string) => ProviderError;
+/** A definitive JSON-RPC "not found" (`not found`, `couldn't get tx: not found`, …). */
+export declare function isNodeNotFound(error: unknown): boolean;
+/** A definitive HTTP 404 from the Data API. */
+export declare function isHttpNotFound(error: unknown): boolean;
+/** A non-negative integer height, as a number, a bigint or a decimal string. */
+export declare function parseHeight(value: unknown, what?: string): bigint;
+/** `0x…` hex with a trailing 4-byte SHA-256 checksum, as AvalancheGo encodes bytes. */
+export declare function decodeChecked(value: unknown, what: string): Uint8Array;
+/** `0x…` hex of `bytes` with AvalancheGo's checksum. */
+export declare function encodeChecked(bytes: Uint8Array): string;
+/** The JSON block of `getBlock`/`getBlockByHeight`, X-Chain or P-Chain, any block type. */
+export declare function parseBlock(answer: unknown): NodeBlock;
+export declare function parsePlatformStatus(answer: unknown): PlatformStatus;
+/** `getUTXOs` asks for at most this many outputs per page (AvalancheGo's maximum). */
+export declare const UTXO_PAGE = 1024;
+export declare class AvalancheNode {
+    #private;
+    constructor(transport: Transport, vm: AvalancheVm);
+    height(tags: AvalancheCallTags): Promise<bigint>;
+    /** The accepted block at `height`; `null` when the node has none there (yet). */
+    blockAt(height: bigint, tags: AvalancheCallTags): Promise<NodeBlock | null>;
+    blockById(blockId: string, tags: AvalancheCallTags): Promise<NodeBlock | null>;
+    /**
+     * An accepted transaction's signed bytes, which must hash to `txId`; `null` when the node
+     * does not have it in its accepted state.
+     */
+    txBytes(txId: string, tags: AvalancheCallTags): Promise<Uint8Array | null>;
+    /** P-Chain only: committed, aborted, in a mempool, dropped by one, or unknown. */
+    txStatus(txId: string, tags: AvalancheCallTags): Promise<PlatformStatus>;
+    /**
+     * Every output the node lists for `address` (its UTXO set), as raw UTXO bytes, read page
+     * by page. An output listed twice alike is kept once; listed twice differently, the
+     * answer is malformed.
+     */
+    utxos(address: string, tags: AvalancheCallTags): Promise<Uint8Array[]>;
+    /** Issues signed bytes; resolves to the id the node gives them. */
+    issueTx(bytes: Uint8Array, tags: AvalancheCallTags): Promise<string>;
+    /** X-Chain: the fixed fee of a transaction (`txFee`), in nAVAX. */
+    txFee(tags: AvalancheCallTags): Promise<bigint>;
+    /** P-Chain: the current gas price and capacity (Etna's dynamic fees). */
+    feeState(tags: AvalancheCallTags): Promise<FeeState>;
+    /** P-Chain: the weights of the four fee dimensions and the minimum gas price. */
+    feeConfig(tags: AvalancheCallTags): Promise<{
+        readonly weights: FeeWeights;
+        readonly minPrice: bigint;
+    }>;
+}
+/** One transaction of an address's history, as the Data API lists it (newest first). */
+export interface HistoryEntry {
+    readonly txId: string;
+    /** Absent for an X-Chain transaction from before its linearization (no block). */
+    readonly location?: Location;
+}
+export declare class DataApi {
+    #private;
+    constructor(transport: Transport);
+    /** Where the indexer says `txId` is; `null` when it does not know it (404). */
+    locate(txId: string, tags: AvalancheCallTags): Promise<Location | null | 'no-block'>;
+    /** A page of `address`'s transactions, newest first. */
+    history(address: string, options: {
+        readonly cursor?: string;
+        readonly pageSize: number;
+    }, tags: AvalancheCallTags): Promise<{
+        readonly items: readonly HistoryEntry[];
+        readonly next?: string;
+    }>;
+    /** The hash of the indexer's block at height 0 (its identity probe). */
+    static blockZero(answer: unknown): string;
+    /** The indexer's newest block height (its height probe). */
+    static latestHeight(answer: unknown): bigint;
+}