crypto-aio 0.0.3 → 0.2.0

package/dist/adapters/solana/reader.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Solana addresses, reads and the `ext.solana` API. Every call carries the tags of the
+ * `ChainDriver` contract table: `read` for point queries, `monitor` for heights and
+ * observations. Heads are read at `confirmed`, finality at `finalized`.
+ */
+import type { AddressCodec, ChainReader, DriverBlock } from '../../core/driver/types';
+import type { Logger } from '../../core/events/logger';
+import type { AssetRef } from '../../core/model/asset';
+import type { ChainInfo, NetworkInfo } from '../../core/model/chain';
+import type { Transport } from '../../core/transport/types';
+import { type ParsedTransaction } from './decode';
+import type { HeightIndex } from './heights';
+import type { SolanaNetworkConfig } from './network';
+import { type BlockHeader } from './rpc';
+import type { SolanaCallTags, SolanaCodec, SolanaExt, SolanaTokenAccount } from './types';
+/** What every Solana port is built from. */
+export interface SolanaContext {
+    readonly transport: Transport;
+    readonly codec: SolanaCodec;
+    readonly chain: ChainInfo;
+    readonly network: NetworkInfo;
+    readonly config: SolanaNetworkConfig;
+    readonly heights: HeightIndex;
+    readonly log: Logger;
+    /** The next build variant (`fees.ts`, `variantCounter`). */
+    readonly nextVariant: () => number;
+}
+export interface AccountInfo {
+    readonly owner: string;
+    readonly executable: boolean;
+    readonly data: Uint8Array;
+}
+/** `getAccountInfo` (base64) at `confirmed`; `null` when the account does not exist. */
+export declare function accountInfo(ctx: SolanaContext, address: string, tags: SolanaCallTags): Promise<AccountInfo | null>;
+/** The mint of an `spl` asset ref; any other standard is not a Solana token. */
+export declare function mintOf(asset: AssetRef): string;
+/**
+ * A classic Token mint's decimals: a missing mint, an account of another
+ * program or data that does not parse is the token's own `ASSET_RESOLUTION`; a Token-2022
+ * mint is `UNSUPPORTED_CAPABILITY`. A definitive node error is made retryable;
+ * `PROVIDER_MISCONFIGURED` and retryable errors propagate unchanged. Under a quorum (the
+ * token metadata the core caches), endpoints must agree on the verdict: a lagging one that
+ * has no mint yet, or one with other decimals, decides nothing (`PROVIDER_INCONSISTENT`).
+ */
+export declare function mintDecimals(ctx: SolanaContext, mint: string, tags: SolanaCallTags): Promise<number>;
+export declare function createSolanaAddressCodec(): AddressCodec;
+/**
+ * The block at dense `height` (`confirmed`), checked against the height it claims; `null`
+ * while the endpoint has no block there. A contradicting answer is a retryable
+ * `PROVIDER_INCONSISTENT`, and the cached slot it came from is dropped.
+ */
+export declare function blockAtHeight(ctx: SolanaContext, height: bigint, tags: SolanaCallTags): Promise<{
+    readonly slot: bigint;
+    readonly block: DriverBlock;
+} | null>;
+/**
+ * Reads a transaction at `confirmed`, with its block's height and hash. The answer must be
+ * the transaction asked for: another one decides nothing (a retryable "not yet"), never
+ * reads as ours.
+ */
+export declare function readTransaction(ctx: SolanaContext, signature: string, tags: SolanaCallTags): Promise<{
+    readonly parsed: ParsedTransaction;
+    readonly header: BlockHeader;
+} | null>;
+/**
+ * Token metadata is read under the proof quorum, stricter than
+ * the contract table's minimum: the core caches a token's decimals and "no such token" for
+ * the container's life, so one lagging or wrong endpoint must not mis-scale every amount
+ * until a restart. `mintDecimals` compares the mint's verdict only. The builder reads the
+ * decimals it signs into `transferChecked` the same way, so a lagging
+ * endpoint without the mint decides nothing instead of refusing the transfer.
+ */
+export declare const METADATA: SolanaCallTags;
+export declare function createSolanaReader(ctx: SolanaContext): ChainReader;
+/**
+ * The classic token accounts of `owner`, optionally for one mint. The answer is filtered to
+ * what was asked (lookups by id): an account of another owner or mint, as a node that
+ * drops a filter would list it, is none of the owner's. Token-2022 accounts are skipped
+ * (unsupported). An account listed twice is malformed, never a doubled balance.
+ */
+export declare function tokenAccountsOf(ctx: SolanaContext, owner: string, mint: string | undefined, tags: SolanaCallTags): Promise<SolanaTokenAccount[]>;
+export declare function createSolanaExt(ctx: SolanaContext): SolanaExt;

package/dist/adapters/solana/reader.js

@@ -0,0 +1,326 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METADATA = void 0;
+exports.accountInfo = accountInfo;
+exports.mintOf = mintOf;
+exports.mintDecimals = mintDecimals;
+exports.createSolanaAddressCodec = createSolanaAddressCodec;
+exports.blockAtHeight = blockAtHeight;
+exports.readTransaction = readTransaction;
+exports.createSolanaReader = createSolanaReader;
+exports.tokenAccountsOf = tokenAccountsOf;
+exports.createSolanaExt = createSolanaExt;
+const error_1 = require("../../core/errors/error");
+const decode_1 = require("./decode");
+const keys_1 = require("./keys");
+const programs_1 = require("./programs");
+const rpc_1 = require("./rpc");
+/**
+ * Account data in agave's `base64` encoding, refused unless it is canonical: Node decodes
+ * leniently (a stray character is skipped, `AB==` reads as `AA==`), so the bytes must
+ * encode back to the same text. The check is linear, which matters: accounts hold up to
+ * 10 MiB, and a repeated-group regex overflows the stack on a few MiB.
+ */
+function base64Data(value, what) {
+    if (!Array.isArray(value) ||
+        value.length !== 2 ||
+        value[1] !== 'base64' ||
+        typeof value[0] !== 'string' ||
+        value[0].length % 4 !== 0) {
+        throw (0, rpc_1.malformed)(what);
+    }
+    const bytes = Buffer.from(value[0], 'base64');
+    if (bytes.toString('base64') !== value[0])
+        throw (0, rpc_1.malformed)(what);
+    return new Uint8Array(bytes);
+}
+/** A `getAccountInfo` answer (base64): the account, or `null` when it does not exist. */
+function parseAccount(result) {
+    const value = (0, rpc_1.contextValue)(result, 'getAccountInfo');
+    if (value === null)
+        return null;
+    const account = (0, rpc_1.record)(value);
+    if (!account || !(0, keys_1.isAddress)(account.owner) || typeof account.executable !== 'boolean') {
+        throw (0, rpc_1.malformed)('getAccountInfo');
+    }
+    return {
+        owner: account.owner,
+        executable: account.executable,
+        data: base64Data(account.data, 'getAccountInfo'),
+    };
+}
+/** `getAccountInfo` (base64) at `confirmed`; `null` when the account does not exist. */
+async function accountInfo(ctx, address, tags) {
+    return parseAccount(await (0, rpc_1.call)(ctx.transport, 'getAccountInfo', [address, { encoding: 'base64', commitment: 'confirmed' }], tags));
+}
+const assetError = (reason) => new error_1.ValidationError('ASSET_RESOLUTION', reason);
+/** The mint of an `spl` asset ref; any other standard is not a Solana token. */
+function mintOf(asset) {
+    if (asset === 'native' || asset.standard !== 'spl') {
+        throw assetError(`Solana tokens use the 'spl' standard`);
+    }
+    if (!(0, keys_1.isAddress)(asset.contract))
+        throw assetError('not a Solana mint address');
+    return asset.contract;
+}
+/**
+ * The verdict of a mint account, by its owning program first: a classic mint and a
+ * Token-2022 one cannot be told apart by their size.
+ */
+function mintVerdict(info) {
+    if (!info)
+        return { refused: 'missing' };
+    if (info.owner === programs_1.TOKEN_2022_PROGRAM)
+        return { refused: 'token-2022' };
+    if (info.owner !== programs_1.TOKEN_PROGRAM)
+        return { refused: 'other-program' };
+    const decoded = (0, programs_1.decodeMint)(info.data);
+    return decoded ? { decimals: decoded.decimals } : { refused: 'unparsable' };
+}
+/**
+ * A mint read's quorum key, verdict fields only: the verdict itself, never the
+ * context slot, the lamports or the supply, on which honest endpoints differ. A malformed
+ * answer keys as such, so it never agrees with a verdict.
+ */
+function mintKey(result) {
+    try {
+        return mintVerdict(parseAccount(result));
+    }
+    catch {
+        return 'malformed';
+    }
+}
+/**
+ * A classic Token mint's decimals: a missing mint, an account of another
+ * program or data that does not parse is the token's own `ASSET_RESOLUTION`; a Token-2022
+ * mint is `UNSUPPORTED_CAPABILITY`. A definitive node error is made retryable;
+ * `PROVIDER_MISCONFIGURED` and retryable errors propagate unchanged. Under a quorum (the
+ * token metadata the core caches), endpoints must agree on the verdict: a lagging one that
+ * has no mint yet, or one with other decimals, decides nothing (`PROVIDER_INCONSISTENT`).
+ */
+async function mintDecimals(ctx, mint, tags) {
+    let info;
+    try {
+        info = await accountInfo(ctx, mint, { ...tags, quorumKey: mintKey });
+    }
+    catch (error) {
+        if ((0, error_1.isCryptoAioError)(error, 'RPC_ERROR') && !error.retryable) {
+            throw (0, error_1.withContext)(error, {}, { retryable: true });
+        }
+        throw error;
+    }
+    const verdict = mintVerdict(info);
+    if ('decimals' in verdict)
+        return verdict.decimals;
+    switch (verdict.refused) {
+        case 'missing':
+            throw assetError('no mint at this address');
+        case 'token-2022':
+            throw new error_1.UnsupportedCapabilityError('UNSUPPORTED_CAPABILITY', 'Token-2022 mints are not supported');
+        case 'other-program':
+            throw assetError('not an SPL token mint');
+        case 'unparsable':
+            throw assetError('the mint does not parse');
+    }
+}
+function createSolanaAddressCodec() {
+    return {
+        validate: (value) => (0, keys_1.isAddress)(value),
+        normalize: (value) => {
+            if (!(0, keys_1.isAddress)(value)) {
+                throw new error_1.ValidationError('INVALID_ADDRESS', 'not a Solana address');
+            }
+            return { canonical: value, display: value };
+        },
+        fromPublicKey: (publicKey) => {
+            const canonical = (0, keys_1.addressFromPublicKey)(publicKey);
+            return { canonical, display: canonical };
+        },
+    };
+}
+function driverBlock(height, header) {
+    return {
+        height,
+        hash: header.blockhash,
+        parentHash: header.previousBlockhash,
+        ...(header.blockTime !== undefined ? { timestamp: header.blockTime } : {}),
+    };
+}
+/**
+ * The block at dense `height` (`confirmed`), checked against the height it claims; `null`
+ * while the endpoint has no block there. A contradicting answer is a retryable
+ * `PROVIDER_INCONSISTENT`, and the cached slot it came from is dropped.
+ */
+async function blockAtHeight(ctx, height, tags) {
+    const slot = await ctx.heights.slotAt(height, 'confirmed', tags);
+    if (slot === null)
+        return null;
+    const header = await ctx.heights.header(slot, 'confirmed', tags);
+    if (!header)
+        return null;
+    if (header.blockHeight !== height) {
+        ctx.heights.forget();
+        throw (0, rpc_1.inconsistent)(`the block at slot ${slot} is not at height ${height}`);
+    }
+    return { slot, block: driverBlock(height, header) };
+}
+/**
+ * Reads a transaction at `confirmed`, with its block's height and hash. The answer must be
+ * the transaction asked for: another one decides nothing (a retryable "not yet"), never
+ * reads as ours.
+ */
+async function readTransaction(ctx, signature, tags) {
+    const result = await (0, rpc_1.call)(ctx.transport, 'getTransaction', [signature, (0, rpc_1.parsedOptions)('confirmed')], tags);
+    if (result === null)
+        return null;
+    const parsed = (0, decode_1.parseTransaction)(result, signature);
+    if (parsed.slot === undefined)
+        throw (0, rpc_1.malformed)('getTransaction');
+    const header = await ctx.heights.header(parsed.slot, 'confirmed', tags);
+    if (!header)
+        throw (0, rpc_1.notYet)('the block of the transaction');
+    return { parsed, header };
+}
+/**
+ * Token metadata is read under the proof quorum, stricter than
+ * the contract table's minimum: the core caches a token's decimals and "no such token" for
+ * the container's life, so one lagging or wrong endpoint must not mis-scale every amount
+ * until a restart. `mintDecimals` compares the mint's verdict only. The builder reads the
+ * decimals it signs into `transferChecked` the same way, so a lagging
+ * endpoint without the mint decides nothing instead of refusing the transfer.
+ */
+exports.METADATA = Object.freeze({ ...rpc_1.READ, quorum: 'proof' });
+function createSolanaReader(ctx) {
+    const height = async (commitment) => (0, rpc_1.u64)(await (0, rpc_1.call)(ctx.transport, 'getBlockHeight', [{ commitment }], rpc_1.MONITOR), 'getBlockHeight');
+    return {
+        getBalance: async (address, asset) => {
+            if (asset === 'native') {
+                return (0, rpc_1.u64)((0, rpc_1.contextValue)(await (0, rpc_1.call)(ctx.transport, 'getBalance', [address, { commitment: 'confirmed' }], rpc_1.READ), 'getBalance'), 'balance');
+            }
+            const mint = mintOf(asset);
+            const accounts = await tokenAccountsOf(ctx, address, mint, rpc_1.READ);
+            return accounts.reduce((sum, account) => sum + account.amount, 0n);
+        },
+        getBlockHeight: () => height('confirmed'),
+        getFinalizedHeight: () => height('finalized'),
+        getBlock: async (ref) => {
+            if (typeof ref !== 'bigint') {
+                throw new error_1.UnsupportedCapabilityError('UNSUPPORTED_CAPABILITY', 'Solana has no block lookup by hash; pass a block height');
+            }
+            return (await blockAtHeight(ctx, ref, rpc_1.READ))?.block ?? null;
+        },
+        getTransaction: async (id) => {
+            if (!(0, keys_1.isSignature)(id))
+                return null;
+            const found = await readTransaction(ctx, id, rpc_1.READ);
+            if (!found)
+                return null;
+            return (0, decode_1.decodeTransaction)(found.parsed, {
+                height: found.header.blockHeight,
+                hash: found.header.blockhash,
+                ...(found.parsed.blockTime !== undefined
+                    ? { blockTime: found.parsed.blockTime }
+                    : {}),
+            });
+        },
+        observe: async (ref, ordering, from) => {
+            if (!(0, keys_1.isSignature)(ref.id))
+                return { seen: 'none' };
+            const found = await readTransaction(ctx, ref.id, rpc_1.MONITOR);
+            if (!found)
+                return { seen: 'none' };
+            const { parsed, header } = found;
+            let success = parsed.err === null;
+            let reason = success ? undefined : 'transaction failed';
+            // The phantom-success guard applies to our own Attempts only. This is
+            // one endpoint's `confirmed` view, so the core records it as observed evidence,
+            // never terminal: a verdict reads the finalized transaction under the proof quorum's
+            // key (`proofs.ts`). A node that drops the token instruction makes the transfer look
+            // native here, which that verdict catches.
+            if (success && ordering !== undefined && from !== undefined) {
+                if (!(0, decode_1.tokenTransfersLanded)(parsed, from)) {
+                    success = false;
+                    reason = 'token transfer failed';
+                }
+            }
+            return {
+                seen: 'block',
+                txHash: parsed.signature,
+                blockHeight: header.blockHeight,
+                blockHash: header.blockhash,
+                success,
+                ...(reason !== undefined ? { reason } : {}),
+            };
+        },
+        getTokenMetadata: async (ref) => {
+            const mint = mintOf(ref);
+            const decimals = await mintDecimals(ctx, mint, exports.METADATA);
+            // SPL mints carry no symbol on chain: a registered token has its own; any other
+            // shows the first characters of its mint (display only).
+            return { symbol: mint.slice(0, 8), decimals };
+        },
+        normalizeTokenRef: (ref) => ({ standard: 'spl', contract: mintOf(ref) }),
+    };
+}
+/**
+ * The classic token accounts of `owner`, optionally for one mint. The answer is filtered to
+ * what was asked (lookups by id): an account of another owner or mint, as a node that
+ * drops a filter would list it, is none of the owner's. Token-2022 accounts are skipped
+ * (unsupported). An account listed twice is malformed, never a doubled balance.
+ */
+async function tokenAccountsOf(ctx, owner, mint, tags) {
+    const value = (0, rpc_1.contextValue)(await (0, rpc_1.call)(ctx.transport, 'getTokenAccountsByOwner', [
+        owner,
+        mint !== undefined ? { mint } : { programId: programs_1.TOKEN_PROGRAM },
+        { encoding: 'base64', commitment: 'confirmed' },
+    ], tags), 'getTokenAccountsByOwner');
+    if (!Array.isArray(value))
+        throw (0, rpc_1.malformed)('getTokenAccountsByOwner');
+    const accounts = [];
+    const listed = new Set();
+    for (const entry of value) {
+        const item = (0, rpc_1.record)(entry);
+        const account = (0, rpc_1.record)(item?.account);
+        if (!item ||
+            !account ||
+            !(0, keys_1.isAddress)(item.pubkey) ||
+            listed.has(item.pubkey) ||
+            !(0, keys_1.isAddress)(account.owner)) {
+            throw (0, rpc_1.malformed)('getTokenAccountsByOwner');
+        }
+        listed.add(item.pubkey);
+        if (account.owner !== programs_1.TOKEN_PROGRAM)
+            continue; // Token-2022 is unsupported.
+        const decoded = (0, programs_1.decodeTokenAccount)(base64Data(account.data, 'getTokenAccountsByOwner'));
+        if (!decoded)
+            throw (0, rpc_1.malformed)('getTokenAccountsByOwner');
+        const accountMint = (0, keys_1.encodeBase58)(decoded.mint);
+        if ((0, keys_1.encodeBase58)(decoded.owner) !== owner)
+            continue;
+        if (mint !== undefined && accountMint !== mint)
+            continue;
+        accounts.push({
+            address: item.pubkey,
+            mint: accountMint,
+            amount: decoded.amount,
+            frozen: decoded.frozen,
+        });
+    }
+    return accounts;
+}
+function createSolanaExt(ctx) {
+    return {
+        solana: {
+            getTokenAccounts: async (owner, mint) => {
+                if (!(0, keys_1.isAddress)(owner)) {
+                    throw new error_1.ValidationError('INVALID_ADDRESS', 'not a Solana address');
+                }
+                if (mint !== undefined && (0, keys_1.decodeBase58)(mint, 32) === null) {
+                    throw new error_1.ValidationError('INVALID_ADDRESS', 'not a Solana mint address');
+                }
+                return tokenAccountsOf(ctx, owner, mint, rpc_1.READ);
+            },
+        },
+    };
+}
+//# sourceMappingURL=reader.js.map

package/dist/adapters/solana/reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader.js","sourceRoot":"","sources":["../../../src/adapters/solana/reader.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Solana addresses, reads and the `ext.solana` API. Every call carries the tags of the\n * `ChainDriver` contract table: `read` for point queries, `monitor` for heights and\n * observations. Heads are read at `confirmed`, finality at `finalized`.\n */\nimport type {\n  AddressCodec,\n  ChainReader,\n  DriverBlock,\n  DriverTxObservation,\n} from '../../core/driver/types';\nimport {\n  UnsupportedCapabilityError,\n  ValidationError,\n  isCryptoAioError,\n  withContext,\n} from '../../core/errors/error';\nimport type { Logger } from '../../core/events/logger';\nimport type { AssetMetadata, AssetRef, TokenRef } from '../../core/model/asset';\nimport type { ChainInfo, NetworkInfo } from '../../core/model/chain';\nimport type { Transport } from '../../core/transport/types';\nimport {\n  decodeTransaction,\n  parseTransaction,\n  tokenTransfersLanded,\n  type ParsedTransaction,\n} from './decode';\nimport type { HeightIndex } from './heights';\nimport {\n  addressFromPublicKey,\n  decodeBase58,\n  encodeBase58,\n  isAddress,\n  isSignature,\n} from './keys';\nimport type { SolanaNetworkConfig } from './network';\nimport {\n  TOKEN_2022_PROGRAM,\n  TOKEN_PROGRAM,\n  decodeMint,\n  decodeTokenAccount,\n} from './programs';\nimport {\n  MONITOR,\n  READ,\n  call,\n  contextValue,\n  inconsistent,\n  malformed,\n  notYet,\n  parsedOptions,\n  record,\n  u64,\n  type BlockHeader,\n} from './rpc';\nimport type { SolanaCallTags, SolanaCodec, SolanaExt, SolanaTokenAccount } from './types';\n\n/** What every Solana port is built from. */\nexport interface SolanaContext {\n  readonly transport: Transport;\n  readonly codec: SolanaCodec;\n  readonly chain: ChainInfo;\n  readonly network: NetworkInfo;\n  readonly config: SolanaNetworkConfig;\n  readonly heights: HeightIndex;\n  readonly log: Logger;\n  /** The next build variant (`fees.ts`, `variantCounter`). */\n  readonly nextVariant: () => number;\n}\n\nexport interface AccountInfo {\n  readonly owner: string;\n  readonly executable: boolean;\n  readonly data: Uint8Array;\n}\n\n/**\n * Account data in agave's `base64` encoding, refused unless it is canonical: Node decodes\n * leniently (a stray character is skipped, `AB==` reads as `AA==`), so the bytes must\n * encode back to the same text. The check is linear, which matters: accounts hold up to\n * 10 MiB, and a repeated-group regex overflows the stack on a few MiB.\n */\nfunction base64Data(value: unknown, what: string): Uint8Array {\n  if (\n    !Array.isArray(value) ||\n    value.length !== 2 ||\n    value[1] !== 'base64' ||\n    typeof value[0] !== 'string' ||\n    value[0].length % 4 !== 0\n  ) {\n    throw malformed(what);\n  }\n  const bytes = Buffer.from(value[0], 'base64');\n  if (bytes.toString('base64') !== value[0]) throw malformed(what);\n  return new Uint8Array(bytes);\n}\n\n/** A `getAccountInfo` answer (base64): the account, or `null` when it does not exist. */\nfunction parseAccount(result: unknown): AccountInfo | null {\n  const value = contextValue(result, 'getAccountInfo');\n  if (value === null) return null;\n  const account = record(value);\n  if (!account || !isAddress(account.owner) || typeof account.executable !== 'boolean') {\n    throw malformed('getAccountInfo');\n  }\n  return {\n    owner: account.owner,\n    executable: account.executable,\n    data: base64Data(account.data, 'getAccountInfo'),\n  };\n}\n\n/** `getAccountInfo` (base64) at `confirmed`; `null` when the account does not exist. */\nexport async function accountInfo(\n  ctx: SolanaContext,\n  address: string,\n  tags: SolanaCallTags,\n): Promise<AccountInfo | null> {\n  return parseAccount(\n    await call(\n      ctx.transport,\n      'getAccountInfo',\n      [address, { encoding: 'base64', commitment: 'confirmed' }],\n      tags,\n    ),\n  );\n}\n\nconst assetError = (reason: string) => new ValidationError('ASSET_RESOLUTION', reason);\n\n/** The mint of an `spl` asset ref; any other standard is not a Solana token. */\nexport function mintOf(asset: AssetRef): string {\n  if (asset === 'native' || asset.standard !== 'spl') {\n    throw assetError(`Solana tokens use the 'spl' standard`);\n  }\n  if (!isAddress(asset.contract)) throw assetError('not a Solana mint address');\n  return asset.contract;\n}\n\n/** What a mint account says about its token: the only fields a mint read decides on. */\ntype MintVerdict =\n  | { readonly decimals: number }\n  | { readonly refused: 'missing' | 'token-2022' | 'other-program' | 'unparsable' };\n\n/**\n * The verdict of a mint account, by its owning program first: a classic mint and a\n * Token-2022 one cannot be told apart by their size.\n */\nfunction mintVerdict(info: AccountInfo | null): MintVerdict {\n  if (!info) return { refused: 'missing' };\n  if (info.owner === TOKEN_2022_PROGRAM) return { refused: 'token-2022' };\n  if (info.owner !== TOKEN_PROGRAM) return { refused: 'other-program' };\n  const decoded = decodeMint(info.data);\n  return decoded ? { decimals: decoded.decimals } : { refused: 'unparsable' };\n}\n\n/**\n * A mint read's quorum key, verdict fields only: the verdict itself, never the\n * context slot, the lamports or the supply, on which honest endpoints differ. A malformed\n * answer keys as such, so it never agrees with a verdict.\n */\nfunction mintKey(result: unknown): unknown {\n  try {\n    return mintVerdict(parseAccount(result));\n  } catch {\n    return 'malformed';\n  }\n}\n\n/**\n * A classic Token mint's decimals: a missing mint, an account of another\n * program or data that does not parse is the token's own `ASSET_RESOLUTION`; a Token-2022\n * mint is `UNSUPPORTED_CAPABILITY`. A definitive node error is made retryable;\n * `PROVIDER_MISCONFIGURED` and retryable errors propagate unchanged. Under a quorum (the\n * token metadata the core caches), endpoints must agree on the verdict: a lagging one that\n * has no mint yet, or one with other decimals, decides nothing (`PROVIDER_INCONSISTENT`).\n */\nexport async function mintDecimals(\n  ctx: SolanaContext,\n  mint: string,\n  tags: SolanaCallTags,\n): Promise<number> {\n  let info: AccountInfo | null;\n  try {\n    info = await accountInfo(ctx, mint, { ...tags, quorumKey: mintKey });\n  } catch (error) {\n    if (isCryptoAioError(error, 'RPC_ERROR') && !error.retryable) {\n      throw withContext(error, {}, { retryable: true });\n    }\n    throw error;\n  }\n  const verdict = mintVerdict(info);\n  if ('decimals' in verdict) return verdict.decimals;\n  switch (verdict.refused) {\n    case 'missing':\n      throw assetError('no mint at this address');\n    case 'token-2022':\n      throw new UnsupportedCapabilityError(\n        'UNSUPPORTED_CAPABILITY',\n        'Token-2022 mints are not supported',\n      );\n    case 'other-program':\n      throw assetError('not an SPL token mint');\n    case 'unparsable':\n      throw assetError('the mint does not parse');\n  }\n}\n\nexport function createSolanaAddressCodec(): AddressCodec {\n  return {\n    validate: (value) => isAddress(value),\n    normalize: (value) => {\n      if (!isAddress(value)) {\n        throw new ValidationError('INVALID_ADDRESS', 'not a Solana address');\n      }\n      return { canonical: value, display: value };\n    },\n    fromPublicKey: (publicKey) => {\n      const canonical = addressFromPublicKey(publicKey);\n      return { canonical, display: canonical };\n    },\n  };\n}\n\nfunction driverBlock(height: bigint, header: BlockHeader): DriverBlock {\n  return {\n    height,\n    hash: header.blockhash,\n    parentHash: header.previousBlockhash,\n    ...(header.blockTime !== undefined ? { timestamp: header.blockTime } : {}),\n  };\n}\n\n/**\n * The block at dense `height` (`confirmed`), checked against the height it claims; `null`\n * while the endpoint has no block there. A contradicting answer is a retryable\n * `PROVIDER_INCONSISTENT`, and the cached slot it came from is dropped.\n */\nexport async function blockAtHeight(\n  ctx: SolanaContext,\n  height: bigint,\n  tags: SolanaCallTags,\n): Promise<{ readonly slot: bigint; readonly block: DriverBlock } | null> {\n  const slot = await ctx.heights.slotAt(height, 'confirmed', tags);\n  if (slot === null) return null;\n  const header = await ctx.heights.header(slot, 'confirmed', tags);\n  if (!header) return null;\n  if (header.blockHeight !== height) {\n    ctx.heights.forget();\n    throw inconsistent(`the block at slot ${slot} is not at height ${height}`);\n  }\n  return { slot, block: driverBlock(height, header) };\n}\n\n/**\n * Reads a transaction at `confirmed`, with its block's height and hash. The answer must be\n * the transaction asked for: another one decides nothing (a retryable \"not yet\"), never\n * reads as ours.\n */\nexport async function readTransaction(\n  ctx: SolanaContext,\n  signature: string,\n  tags: SolanaCallTags,\n): Promise<{ readonly parsed: ParsedTransaction; readonly header: BlockHeader } | null> {\n  const result = await call(\n    ctx.transport,\n    'getTransaction',\n    [signature, parsedOptions('confirmed')],\n    tags,\n  );\n  if (result === null) return null;\n  const parsed = parseTransaction(result, signature);\n  if (parsed.slot === undefined) throw malformed('getTransaction');\n  const header = await ctx.heights.header(parsed.slot, 'confirmed', tags);\n  if (!header) throw notYet('the block of the transaction');\n  return { parsed, header };\n}\n\n/**\n * Token metadata is read under the proof quorum, stricter than\n * the contract table's minimum: the core caches a token's decimals and \"no such token\" for\n * the container's life, so one lagging or wrong endpoint must not mis-scale every amount\n * until a restart. `mintDecimals` compares the mint's verdict only. The builder reads the\n * decimals it signs into `transferChecked` the same way, so a lagging\n * endpoint without the mint decides nothing instead of refusing the transfer.\n */\nexport const METADATA: SolanaCallTags = Object.freeze({ ...READ, quorum: 'proof' });\n\nexport function createSolanaReader(ctx: SolanaContext): ChainReader {\n  const height = async (commitment: 'confirmed' | 'finalized') =>\n    u64(\n      await call(ctx.transport, 'getBlockHeight', [{ commitment }], MONITOR),\n      'getBlockHeight',\n    );\n  return {\n    getBalance: async (address, asset) => {\n      if (asset === 'native') {\n        return u64(\n          contextValue(\n            await call(\n              ctx.transport,\n              'getBalance',\n              [address, { commitment: 'confirmed' }],\n              READ,\n            ),\n            'getBalance',\n          ),\n          'balance',\n        );\n      }\n      const mint = mintOf(asset);\n      const accounts = await tokenAccountsOf(ctx, address, mint, READ);\n      return accounts.reduce((sum, account) => sum + account.amount, 0n);\n    },\n    getBlockHeight: () => height('confirmed'),\n    getFinalizedHeight: () => height('finalized'),\n    getBlock: async (ref) => {\n      if (typeof ref !== 'bigint') {\n        throw new UnsupportedCapabilityError(\n          'UNSUPPORTED_CAPABILITY',\n          'Solana has no block lookup by hash; pass a block height',\n        );\n      }\n      return (await blockAtHeight(ctx, ref, READ))?.block ?? null;\n    },\n    getTransaction: async (id) => {\n      if (!isSignature(id)) return null;\n      const found = await readTransaction(ctx, id, READ);\n      if (!found) return null;\n      return decodeTransaction(found.parsed, {\n        height: found.header.blockHeight,\n        hash: found.header.blockhash,\n        ...(found.parsed.blockTime !== undefined\n          ? { blockTime: found.parsed.blockTime }\n          : {}),\n      });\n    },\n    observe: async (ref, ordering, from): Promise<DriverTxObservation> => {\n      if (!isSignature(ref.id)) return { seen: 'none' };\n      const found = await readTransaction(ctx, ref.id, MONITOR);\n      if (!found) return { seen: 'none' };\n      const { parsed, header } = found;\n      let success = parsed.err === null;\n      let reason = success ? undefined : 'transaction failed';\n      // The phantom-success guard applies to our own Attempts only. This is\n      // one endpoint's `confirmed` view, so the core records it as observed evidence,\n      // never terminal: a verdict reads the finalized transaction under the proof quorum's\n      // key (`proofs.ts`). A node that drops the token instruction makes the transfer look\n      // native here, which that verdict catches.\n      if (success && ordering !== undefined && from !== undefined) {\n        if (!tokenTransfersLanded(parsed, from)) {\n          success = false;\n          reason = 'token transfer failed';\n        }\n      }\n      return {\n        seen: 'block',\n        txHash: parsed.signature,\n        blockHeight: header.blockHeight,\n        blockHash: header.blockhash,\n        success,\n        ...(reason !== undefined ? { reason } : {}),\n      };\n    },\n    getTokenMetadata: async (ref: TokenRef): Promise<AssetMetadata> => {\n      const mint = mintOf(ref);\n      const decimals = await mintDecimals(ctx, mint, METADATA);\n      // SPL mints carry no symbol on chain: a registered token has its own; any other\n      // shows the first characters of its mint (display only).\n      return { symbol: mint.slice(0, 8), decimals };\n    },\n    normalizeTokenRef: (ref) => ({ standard: 'spl', contract: mintOf(ref) }),\n  };\n}\n\n/**\n * The classic token accounts of `owner`, optionally for one mint. The answer is filtered to\n * what was asked (lookups by id): an account of another owner or mint, as a node that\n * drops a filter would list it, is none of the owner's. Token-2022 accounts are skipped\n * (unsupported). An account listed twice is malformed, never a doubled balance.\n */\nexport async function tokenAccountsOf(\n  ctx: SolanaContext,\n  owner: string,\n  mint: string | undefined,\n  tags: SolanaCallTags,\n): Promise<SolanaTokenAccount[]> {\n  const value = contextValue(\n    await call(\n      ctx.transport,\n      'getTokenAccountsByOwner',\n      [\n        owner,\n        mint !== undefined ? { mint } : { programId: TOKEN_PROGRAM },\n        { encoding: 'base64', commitment: 'confirmed' },\n      ],\n      tags,\n    ),\n    'getTokenAccountsByOwner',\n  );\n  if (!Array.isArray(value)) throw malformed('getTokenAccountsByOwner');\n  const accounts: SolanaTokenAccount[] = [];\n  const listed = new Set<string>();\n  for (const entry of value) {\n    const item = record(entry);\n    const account = record(item?.account);\n    if (\n      !item ||\n      !account ||\n      !isAddress(item.pubkey) ||\n      listed.has(item.pubkey) ||\n      !isAddress(account.owner)\n    ) {\n      throw malformed('getTokenAccountsByOwner');\n    }\n    listed.add(item.pubkey);\n    if (account.owner !== TOKEN_PROGRAM) continue; // Token-2022 is unsupported.\n    const decoded = decodeTokenAccount(\n      base64Data(account.data, 'getTokenAccountsByOwner'),\n    );\n    if (!decoded) throw malformed('getTokenAccountsByOwner');\n    const accountMint = encodeBase58(decoded.mint);\n    if (encodeBase58(decoded.owner) !== owner) continue;\n    if (mint !== undefined && accountMint !== mint) continue;\n    accounts.push({\n      address: item.pubkey,\n      mint: accountMint,\n      amount: decoded.amount,\n      frozen: decoded.frozen,\n    });\n  }\n  return accounts;\n}\n\nexport function createSolanaExt(ctx: SolanaContext): SolanaExt {\n  return {\n    solana: {\n      getTokenAccounts: async (owner, mint) => {\n        if (!isAddress(owner)) {\n          throw new ValidationError('INVALID_ADDRESS', 'not a Solana address');\n        }\n        if (mint !== undefined && decodeBase58(mint, 32) === null) {\n          throw new ValidationError('INVALID_ADDRESS', 'not a Solana mint address');\n        }\n        return tokenAccountsOf(ctx, owner, mint, READ);\n      },\n    },\n  };\n}\n"]}

package/dist/adapters/solana/rpc.d.ts

@@ -0,0 +1,102 @@
+/**
+ * The Solana driver's path to the core transport. Every JSON-RPC call
+ * is one direct `transport.rpc` call carrying the tags of the `ChainDriver` method that made
+ * it; `@solana/web3.js` is never on a request path. Answers are validated here: a malformed
+ * answer is a retryable `PROVIDER_UNAVAILABLE`, never a foreign error.
+ */
+import { ProviderError, type CryptoAioError } from '../../core/errors/error';
+import type { Transport } from '../../core/transport/types';
+import type { Commitment, SolanaCallTags } from './types';
+export declare const READ: SolanaCallTags;
+export declare const MONITOR: SolanaCallTags;
+export declare const PROOF: SolanaCallTags;
+export declare const BROADCAST: SolanaCallTags;
+export declare const withSignal: (tags: SolanaCallTags, signal?: AbortSignal) => SolanaCallTags;
+/** Solana's JSON-RPC server errors (agave `rpc-client-api/src/custom_error.rs`). */
+export declare const RPC_CODES: Readonly<{
+    BLOCK_CLEANED_UP: -32001;
+    SEND_TRANSACTION_PREFLIGHT_FAILURE: -32002;
+    TRANSACTION_SIGNATURE_VERIFICATION_FAILURE: -32003;
+    BLOCK_NOT_AVAILABLE: -32004;
+    SLOT_SKIPPED: -32007;
+    LONG_TERM_STORAGE_SLOT_SKIPPED: -32009;
+    TRANSACTION_HISTORY_NOT_AVAILABLE: -32011;
+    BLOCK_STATUS_NOT_AVAILABLE_YET: -32014;
+    MIN_CONTEXT_SLOT_NOT_REACHED: -32016;
+    LONG_TERM_STORAGE_UNREACHABLE: -32019;
+    FILTER_TRANSACTION_NOT_FOUND: -32020;
+}>;
+/** The JSON-RPC code of a definitive, non-ambiguous `RPC_ERROR`; otherwise `undefined`. */
+export declare function rpcCode(error: unknown): number | undefined;
+/** The node's message of a definitive, non-ambiguous `RPC_ERROR`. */
+export declare function rpcMessage(error: CryptoAioError): string;
+/** The endpoint has not reached that block or state yet (`null`, decides nothing). */
+export declare const isNotYet: (error: unknown) => boolean;
+/** The endpoint no longer holds that block or history, or never did (decides nothing). */
+export declare const isGone: (error: unknown) => boolean;
+/** The endpoint says the slot was skipped, or is missing on this endpoint (`-32007`). */
+export declare const isSkipped: (error: unknown) => boolean;
+/** Any answer meaning "this endpoint cannot show that": it never decides anything. */
+export declare const isNotAvailable: (error: unknown) => boolean;
+/** A retryable error that decides nothing: the endpoint no longer holds what was asked. */
+export declare const gone: (what: string) => ProviderError;
+/** A retryable error that decides nothing: the endpoints cannot show this yet. */
+export declare const notYet: (what: string) => ProviderError;
+/**
+ * On a proof path only a definitive negative proof answers "no". Any
+ * other definitive RPC error (agave 4.3.0's `getBlocks` answers `-32602 "BigTable query
+ * failed"` for a range below its local ledger, `-32603` on a blockstore error) decides
+ * nothing: it becomes a retryable `PROVIDER_UNAVAILABLE`. Every other error (retryable
+ * ones, `PROVIDER_MISCONFIGURED`) is returned unchanged.
+ */
+export declare function undecided(error: unknown, what: string): unknown;
+export declare const malformed: (what: string) => ProviderError;
+export declare const inconsistent: (what: string) => ProviderError;
+/** A JSON object's fields, or `null` for anything else (arrays and `null` included). */
+export declare const record: (value: unknown) => Record<string, unknown> | null;
+/**
+ * An unsigned 64-bit JSON integer (lamports, slots, heights) as a `bigint`. Every call
+ * parses with `exactIntegers`, so a value above 2^53 − 1 arrives as a `bigint`; a
+ * number outside the safe range was rounded somewhere and is refused as malformed.
+ */
+export declare function u64(value: unknown, what: string): bigint;
+/** A decimal string of base units (token amounts), as a `bigint`. */
+export declare function amountString(value: unknown, what: string): bigint;
+/** The `value` of an RPC response with context (`{ context: { slot }, value }`). */
+export declare function contextValue(result: unknown, what: string): unknown;
+/** A block header as `getBlock` returns it with `transactionDetails: 'none'`. */
+export interface BlockHeader {
+    readonly blockhash: string;
+    readonly previousBlockhash: string;
+    readonly parentSlot: bigint;
+    readonly blockHeight: bigint;
+    /** Unix seconds, when the node estimates one. */
+    readonly blockTime?: number;
+}
+export declare function blockHeader(result: unknown): BlockHeader;
+export declare const pick: (value: unknown, keys: readonly string[]) => unknown;
+/** The consensus fields of a block header, compared under a quorum. */
+export declare const BLOCK_FIELDS: readonly ["blockhash", "previousBlockhash", "parentSlot", "blockHeight"];
+/**
+ * The consensus facts compared under a quorum, per method. A key that throws
+ * counts as a disagreement (a retryable `PROVIDER_INCONSISTENT`).
+ */
+export declare function quorumKeyFor(method: string): ((result: unknown) => unknown) | undefined;
+/**
+ * One JSON-RPC call through the transport, under the calling driver method's tags. Solana
+ * sends u64 values (lamports) as JSON numbers, so every answer is parsed with
+ * `exactIntegers`: nothing above 2^53 − 1 is ever rounded.
+ */
+export declare function call(transport: Transport, method: string, params: readonly unknown[], tags: SolanaCallTags): Promise<unknown>;
+/** `getBlock` options for a header (no transactions, no rewards). */
+export declare const headerOptions: (commitment: Commitment) => {
+    commitment: Commitment;
+    transactionDetails: string;
+    rewards: boolean;
+};
+/** `getBlock`/`getTransaction` options for decoding (every transaction version we parse). */
+export declare const parsedOptions: (commitment: Commitment) => {
+    commitment: Commitment;
+    encoding: string;
+    maxSupportedTransactionVersion: number;
+};