@macwlt/cli 0.0.1-alpha

package/dist/index.d.ts

@@ -0,0 +1,543 @@
+import { Hex as Hex$1, HttpTransportConfig } from 'viem';
+
+type Result<T, E> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: E;
+};
+declare function ok<T, E>(value: T): Result<T, E>;
+declare function err<T, E>(error: E): Result<T, E>;
+
+type Base64Error = {
+    readonly kind: "empty";
+} | {
+    readonly kind: "invalid";
+    readonly value: string;
+};
+declare function bytesToBase64(bytes: Uint8Array): string;
+declare function base64ToBytes(input: string): Result<Uint8Array, Base64Error>;
+
+interface ConfigStorage {
+    read(path: string): Promise<string | undefined>;
+    write(path: string, contents: string): Promise<void>;
+}
+
+type GlobalConfigValidationError = {
+    readonly kind: "invalid-config";
+    readonly message: string;
+};
+
+type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+declare function parseJsonValue(input: unknown): Result<JsonValue, GlobalConfigValidationError>;
+
+type GlobalConfigData = {
+    readonly [key: string]: JsonValue;
+};
+declare function parseGlobalConfigData(input: unknown): Result<GlobalConfigData, GlobalConfigValidationError>;
+
+type GlobalConfigLoadOptions = {
+    readonly homeDirectory?: string;
+    readonly storage?: ConfigStorage;
+};
+type GlobalConfigLoadError = {
+    readonly kind: "read-failed";
+    readonly path: string;
+    readonly cause: unknown;
+} | {
+    readonly kind: "invalid-json";
+    readonly path: string;
+    readonly message: string;
+} | (GlobalConfigValidationError & {
+    readonly path: string;
+});
+type GlobalConfigSaveError = {
+    readonly kind: "write-failed";
+    readonly path: string;
+    readonly cause: unknown;
+};
+declare class GlobalConfig {
+    #private;
+    private constructor();
+    static load(options?: GlobalConfigLoadOptions): Promise<Result<GlobalConfig, GlobalConfigLoadError>>;
+    get path(): string;
+    get dirty(): boolean;
+    get data(): GlobalConfigData;
+    get(key: string): JsonValue | undefined;
+    set(key: string, input: unknown): Result<void, GlobalConfigValidationError>;
+    delete(key: string): void;
+    replace(input: unknown): Result<void, GlobalConfigValidationError>;
+    save(): Promise<Result<void, GlobalConfigSaveError>>;
+}
+
+declare function createFileIfAbsent(path: string, contents: string): Promise<"created" | "already-exists">;
+
+declare function defaultGlobalConfigContents(): string;
+
+type EnsureGlobalConfigOptions = {
+    readonly homeDirectory?: string;
+    readonly createFile?: typeof createFileIfAbsent;
+};
+type EnsureGlobalConfigError = {
+    readonly kind: "write-failed";
+    readonly path: string;
+    readonly cause: unknown;
+};
+type EnsureGlobalConfigResult = {
+    readonly path: string;
+    readonly created: boolean;
+};
+declare function ensureGlobalConfig(options?: EnsureGlobalConfigOptions): Promise<Result<EnsureGlobalConfigResult, EnsureGlobalConfigError>>;
+
+type ResetGlobalConfigOptions = {
+    readonly homeDirectory?: string;
+    readonly storage?: ConfigStorage;
+};
+type ResetGlobalConfigError = {
+    readonly kind: "write-failed";
+    readonly path: string;
+    readonly cause: unknown;
+};
+declare function resetGlobalConfig(options?: ResetGlobalConfigOptions): Promise<Result<string, ResetGlobalConfigError>>;
+
+declare const fileConfigStorage: ConfigStorage;
+
+declare function globalConfigPath(homeDirectory: string): string;
+
+type AddressType = "bitcoin" | "bitcoin-testnet" | "bitcoin-taproot" | "bitcoin-taproot-testnet" | "ethereum";
+type NativeError = {
+    readonly kind: "load";
+    readonly libraryPath: string;
+    readonly message: string;
+} | {
+    readonly kind: "missing-library";
+    readonly libraryPath: string;
+} | {
+    readonly kind: "wallet-create";
+    readonly message: string;
+} | {
+    readonly kind: "native";
+    readonly operation: string;
+    readonly code: number;
+    readonly message: string;
+} | {
+    readonly kind: "oversized-output";
+    readonly operation: string;
+    readonly size: bigint;
+};
+type NativeClient = {
+    readonly libraryPath: string;
+    readonly close: () => void;
+    readonly withWallet: <T, E>(body: (wallet: NativeWallet) => Result<T, E>) => Result<T, E | NativeError>;
+};
+type NativeWallet = {
+    readonly reset: () => Result<void, NativeError>;
+    readonly bootstrap: () => Result<Uint8Array, NativeError>;
+    readonly exportPubkey: (derivationPath: string) => Result<Uint8Array, NativeError>;
+    readonly exportAddress: (derivationPath: string, addressType: AddressType) => Result<string, NativeError>;
+    readonly signEthereumTransaction: (transaction: Uint8Array) => Result<Uint8Array, NativeError>;
+    readonly signPsbt: (psbt: Uint8Array) => Result<Uint8Array, NativeError>;
+};
+declare function defaultLibraryPath(envPath: string | undefined): string;
+declare function openNativeClient(libraryPath: string): Result<NativeClient, NativeError>;
+
+declare const cliVersion = "0.1.0";
+type CliResult = {
+    readonly exitCode: number;
+    readonly stdout: string;
+    readonly stderr: string;
+};
+type CommandHook = () => Result<void, string> | Promise<Result<void, string>>;
+interface Command<P = unknown> {
+    readonly name: string;
+    readonly aliases?: readonly string[];
+    readonly needsClient?: boolean;
+    readonly beforeRun?: CommandHook;
+    describe(): string;
+    parse(args: readonly string[]): Result<P, string>;
+    run(ctx: CommandContext, parsed: P): Promise<Result<string, string>>;
+}
+interface CommandContext {
+    readonly env: NodeJS.ProcessEnv;
+    readonly client: NativeClient;
+    readonly registry: readonly Command[];
+    readonly configStorage: ConfigStorage;
+}
+type RunCliOptions = {
+    readonly configStorage?: ConfigStorage;
+    readonly createConfigFile?: typeof createFileIfAbsent;
+};
+declare function runCli(args: readonly string[], env?: NodeJS.ProcessEnv, registry?: readonly Command[], options?: RunCliOptions): Promise<CliResult>;
+declare function helpText(registry: readonly Command[]): string;
+
+declare const commands: readonly Command[];
+
+type HexError = {
+    readonly kind: "empty";
+} | {
+    readonly kind: "invalid";
+    readonly value: string;
+};
+declare function bytesToHex(bytes: Uint8Array): string;
+declare function hexToBytes(input: string): Result<Uint8Array, HexError>;
+
+type ParsedFlags = {
+    readonly json: boolean;
+    readonly positionals: readonly string[];
+    readonly options: ReadonlyMap<string, string>;
+    readonly switches: ReadonlySet<string>;
+};
+declare function parseFlags(args: readonly string[]): Result<ParsedFlags, string>;
+
+type BytesInput = {
+    readonly kind: "hex";
+    readonly value: string;
+} | {
+    readonly kind: "base64";
+    readonly value: string;
+} | {
+    readonly kind: "file";
+    readonly path: string;
+};
+declare function parseBytesInput(options: ReadonlyMap<string, string>, allowed: readonly string[]): Result<BytesInput, string>;
+declare function readInput(input: BytesInput): Promise<Result<Uint8Array, string>>;
+
+declare function formatNativeError(error: NativeError): string;
+declare function formatExecutionError(error: string | NativeError): string;
+
+declare function formatDataOutput(bytes: Uint8Array, json: boolean, key: string): string;
+type PsbtTextFormat = "base64" | "hex";
+declare function formatPsbt(bytes: Uint8Array, format: PsbtTextFormat): string;
+
+declare function runWithWallet<T>(client: NativeClient, body: (wallet: NativeWallet) => Result<T, string>): Result<T, string>;
+
+type ConfirmationPrompt = (question: string) => Promise<boolean>;
+declare function terminalConfirmationPrompt(question: string): Promise<boolean>;
+
+declare function createConfirmationHook(prompt?: ConfirmationPrompt): CommandHook;
+
+type ChainId = number & {
+    readonly __brand: "ChainId";
+};
+type RpcUrl = string & {
+    readonly __brand: "RpcUrl";
+};
+type EthereumConfig = {
+    readonly rpcUrl: RpcUrl;
+    readonly chainId: ChainId;
+};
+type EthereumConfigInput = {
+    readonly rpcUrl: string;
+    readonly chainId: number;
+};
+type EthereumConfigError = {
+    readonly kind: "invalid-rpc-url";
+    readonly value: string;
+} | {
+    readonly kind: "invalid-chain-id";
+    readonly value: number;
+};
+declare function parseEthereumConfig(input: EthereumConfigInput): Result<EthereumConfig, EthereumConfigError>;
+
+type Hex = `0x${string}`;
+type EthereumAddress = `0x${string}`;
+type EvmBlockTag = "earliest" | "finalized" | "latest" | "pending" | "safe";
+type EvmBlock = EvmBlockTag | bigint;
+type EvmCallRequest = {
+    readonly to: EthereumAddress;
+    readonly data?: Hex;
+    readonly from?: EthereumAddress;
+    readonly gas?: bigint;
+    readonly gasPrice?: bigint;
+    readonly value?: bigint;
+    readonly block?: EvmBlock;
+};
+type EvmCallResult = {
+    readonly data: Hex | undefined;
+};
+type EvmValidationError = {
+    readonly message: string;
+};
+declare function parseEvmCallRequest(input: EvmCallRequest): Result<EvmCallRequest, EvmValidationError>;
+declare function parseEvmCallResult(input: unknown): Result<EvmCallResult, EvmValidationError>;
+
+type EvmTransactionRequest = {
+    readonly from: EthereumAddress;
+    readonly to: EthereumAddress;
+    readonly data?: Hex;
+    readonly value?: bigint;
+};
+type TransactionHash = Hex;
+
+interface EvmCallTransport {
+    call(request: EvmCallRequest): Promise<unknown>;
+}
+interface EvmTransport extends EvmCallTransport {
+    getChainId(): Promise<unknown>;
+    getTransactionCount(address: string): Promise<unknown>;
+    getBalance(address: string): Promise<unknown>;
+    estimateGas(request: EvmTransactionRequest): Promise<unknown>;
+    getGasPrice(): Promise<unknown>;
+    sendRawTransaction(transaction: string): Promise<unknown>;
+}
+type EvmCallTransportFactory = (config: EthereumConfig) => EvmCallTransport;
+type EthereumClientCreationError = EthereumConfigError | {
+    readonly kind: "transport-creation-failed";
+    readonly cause: unknown;
+};
+type EthereumCallError = {
+    readonly kind: "invalid-request";
+    readonly message: string;
+} | {
+    readonly kind: "transport-failed";
+    readonly cause: unknown;
+} | {
+    readonly kind: "invalid-response";
+    readonly message: string;
+};
+type EthereumTransactionOperation = "get-chain-id" | "get-transaction-count" | "get-balance" | "estimate-gas" | "get-gas-price" | "send-raw-transaction";
+type EthereumTransactionError = {
+    readonly kind: "unsupported-transport";
+} | {
+    readonly kind: "invalid-request";
+    readonly message: string;
+} | {
+    readonly kind: "transport-failed";
+    readonly operation: EthereumTransactionOperation;
+    readonly cause: unknown;
+} | {
+    readonly kind: "invalid-response";
+    readonly operation: EthereumTransactionOperation;
+    readonly message: string;
+} | {
+    readonly kind: "chain-mismatch";
+    readonly expected: number;
+    readonly actual: number;
+};
+declare class EthereumClient {
+    #private;
+    private constructor();
+    static create(input: EthereumConfigInput, createTransport: EvmCallTransportFactory): Result<EthereumClient, EthereumClientCreationError>;
+    get config(): EthereumConfig;
+    call(request: EvmCallRequest): Promise<Result<EvmCallResult, EthereumCallError>>;
+    verifyChain(): Promise<Result<void, EthereumTransactionError>>;
+    getTransactionCount(address: string): Promise<Result<number, EthereumTransactionError>>;
+    estimateGas(request: EvmTransactionRequest): Promise<Result<bigint, EthereumTransactionError>>;
+    getBalance(address: string): Promise<Result<bigint, EthereumTransactionError>>;
+    getGasPrice(): Promise<Result<bigint, EthereumTransactionError>>;
+    sendRawTransaction(transaction: string): Promise<Result<TransactionHash, EthereumTransactionError>>;
+}
+
+type EthereumAsset = {
+    readonly kind: "native-eth";
+} | {
+    readonly kind: "erc20";
+    readonly tokenAddress: EthereumAddress;
+};
+declare function parseEthereumAsset(input: string): Result<EthereumAsset, "invalid-ethereum-asset">;
+
+type LegacyTransaction = {
+    readonly type: "legacy";
+    readonly chainId: number;
+    readonly nonce: number;
+    readonly gas: bigint;
+    readonly gasPrice: bigint;
+    readonly to: EthereumAddress;
+    readonly value: bigint;
+    readonly data: Hex;
+};
+
+type Erc20DecimalsError = {
+    readonly kind: "invalid-token-decimals";
+    readonly message: string;
+};
+declare function decodeErc20Decimals(data: Hex): Result<number, Erc20DecimalsError>;
+
+type Erc20BalanceError = {
+    readonly kind: "invalid-token-balance";
+    readonly message: string;
+};
+declare function decodeErc20Balance(data: Hex): Result<bigint, Erc20BalanceError>;
+
+declare function encodeErc20BalanceOf(account: EthereumAddress): Hex$1;
+
+declare function encodeErc20DecimalsCall(): Hex$1;
+
+declare function encodeErc20Transfer(recipient: EthereumAddress, amount: bigint): Hex$1;
+
+type EthereumAssetBalance = {
+    readonly kind: "native-eth";
+    readonly address: EthereumAddress;
+    readonly balance: string;
+    readonly balanceBaseUnits: bigint;
+    readonly decimals: 18;
+} | {
+    readonly kind: "erc20";
+    readonly address: EthereumAddress;
+    readonly tokenAddress: EthereumAddress;
+    readonly balance: string;
+    readonly balanceBaseUnits: bigint;
+    readonly decimals: number;
+};
+type EthereumBalanceStage = "verify-chain" | "get-native-balance" | "read-token-balance" | "read-token-decimals";
+type EthereumAssetBalanceError = {
+    readonly kind: "chain-client";
+    readonly stage: EthereumBalanceStage;
+    readonly error: EthereumCallError | EthereumTransactionError;
+} | {
+    readonly kind: "missing-token-balance";
+} | {
+    readonly kind: "missing-token-decimals";
+} | {
+    readonly kind: "token-balance";
+    readonly error: Erc20BalanceError;
+} | {
+    readonly kind: "token-decimals";
+    readonly error: Erc20DecimalsError;
+};
+declare function getEthereumAssetBalance(client: EthereumClient, address: EthereumAddress, asset: EthereumAsset): Promise<Result<EthereumAssetBalance, EthereumAssetBalanceError>>;
+
+type ConfiguredErc20Asset = {
+    readonly symbol: string;
+    readonly address: EthereumAddress;
+};
+type ConfiguredEthereumChain = {
+    readonly chainId: number;
+    readonly name: string;
+    readonly rpcUrl: RpcUrl;
+    readonly nativeSymbol: string;
+    readonly assets: readonly ConfiguredErc20Asset[];
+};
+type EthereumPortfolioConfigError = {
+    readonly kind: "invalid-portfolio-config";
+    readonly message: string;
+};
+declare function parseEthereumPortfolioConfig(input: GlobalConfigData): Result<readonly ConfiguredEthereumChain[], EthereumPortfolioConfigError>;
+
+type EthereumPortfolioAssetBalance = {
+    readonly status: "fulfilled";
+    readonly symbol: string;
+    readonly balance: EthereumAssetBalance;
+} | {
+    readonly status: "failed";
+    readonly symbol: string;
+    readonly asset: EthereumAsset;
+    readonly error: EthereumAssetBalanceError;
+};
+type EthereumPortfolioChainBalances = {
+    readonly status: "fulfilled";
+    readonly chain: ConfiguredEthereumChain;
+    readonly assets: readonly EthereumPortfolioAssetBalance[];
+} | {
+    readonly status: "failed";
+    readonly chain: ConfiguredEthereumChain;
+    readonly error: EthereumClientCreationError;
+};
+declare function getEthereumPortfolioBalances(chains: readonly ConfiguredEthereumChain[], address: EthereumAddress, createTransport: EvmCallTransportFactory): Promise<readonly EthereumPortfolioChainBalances[]>;
+
+type TokenAmountError = {
+    readonly kind: "invalid-token-amount";
+    readonly value: string;
+} | {
+    readonly kind: "zero-token-amount";
+};
+declare function parseTokenAmount(value: string, decimals: number): Result<bigint, TokenAmountError>;
+
+type EthereumRpcResolutionError = {
+    readonly kind: "missing-chain-rpc";
+    readonly chainId: number;
+} | {
+    readonly kind: "invalid-chain-rpc";
+    readonly chainId: number;
+};
+declare function resolveEthereumRpcUrl(config: GlobalConfigData, chainId: number): Result<RpcUrl, EthereumRpcResolutionError>;
+
+type EthereumSignatureError = {
+    readonly kind: "invalid-signature-length";
+    readonly actual: number;
+} | {
+    readonly kind: "invalid-signature-parity";
+    readonly actual: number;
+};
+declare function serializeSignedTransaction(transaction: LegacyTransaction, signature: Uint8Array): Result<Hex$1, EthereumSignatureError>;
+
+type Erc20TransactionSigner = {
+    readonly address: EthereumAddress;
+    sign(transaction: Uint8Array): Result<Uint8Array, string>;
+};
+type SendErc20TokenInput = {
+    readonly tokenAddress: EthereumAddress;
+    readonly recipient: EthereumAddress;
+    readonly amount: string;
+};
+type SendErc20TokenResult = {
+    readonly transactionHash: Hex;
+    readonly from: EthereumAddress;
+    readonly amountBaseUnits: bigint;
+    readonly decimals: number;
+};
+type SendErc20Stage = "verify-chain" | "read-token-decimals" | "get-transaction-count" | "estimate-gas" | "get-gas-price" | "broadcast";
+type SendErc20TokenError = {
+    readonly kind: "chain-client";
+    readonly stage: SendErc20Stage;
+    readonly error: EthereumCallError | EthereumTransactionError;
+} | {
+    readonly kind: "missing-token-decimals";
+} | {
+    readonly kind: "token-decimals";
+    readonly error: Erc20DecimalsError;
+} | {
+    readonly kind: "token-amount";
+    readonly error: TokenAmountError;
+} | {
+    readonly kind: "signing-failed";
+    readonly message: string;
+} | {
+    readonly kind: "invalid-signature";
+    readonly error: EthereumSignatureError;
+};
+declare function sendErc20Token(client: EthereumClient, signer: Erc20TransactionSigner, input: SendErc20TokenInput): Promise<Result<SendErc20TokenResult, SendErc20TokenError>>;
+
+type SendNativeEthInput = {
+    readonly recipient: EthereumAddress;
+    readonly amount: string;
+};
+type SendNativeEthResult = {
+    readonly transactionHash: Hex;
+    readonly from: EthereumAddress;
+    readonly amountWei: bigint;
+    readonly feeWei: bigint;
+    readonly balanceWei: bigint;
+};
+type SendNativeEthStage = "verify-chain" | "get-transaction-count" | "get-balance" | "estimate-gas" | "get-gas-price" | "broadcast";
+type SendNativeEthError = {
+    readonly kind: "chain-client";
+    readonly stage: SendNativeEthStage;
+    readonly error: EthereumTransactionError;
+} | {
+    readonly kind: "amount";
+    readonly error: TokenAmountError;
+} | {
+    readonly kind: "insufficient-funds";
+    readonly balanceWei: bigint;
+    readonly requiredWei: bigint;
+} | {
+    readonly kind: "signing-failed";
+    readonly message: string;
+} | {
+    readonly kind: "invalid-signature";
+    readonly error: EthereumSignatureError;
+};
+declare function sendNativeEth(client: EthereumClient, signer: Erc20TransactionSigner, input: SendNativeEthInput): Promise<Result<SendNativeEthResult, SendNativeEthError>>;
+
+declare function serializeUnsignedTransaction(transaction: LegacyTransaction): Hex$1;
+
+type ViemTransportOptions = {
+    readonly fetchFn?: HttpTransportConfig["fetchFn"];
+};
+declare function createViemTransport(config: EthereumConfig, options?: ViemTransportOptions): EvmTransport;
+
+export { type AddressType, type Base64Error, type BytesInput, type ChainId, type CliResult, type Command, type CommandContext, type CommandHook, type ConfigStorage, type ConfiguredErc20Asset, type ConfiguredEthereumChain, type ConfirmationPrompt, type EnsureGlobalConfigError, type EnsureGlobalConfigOptions, type EnsureGlobalConfigResult, type Erc20BalanceError, type Erc20DecimalsError, type Erc20TransactionSigner, type EthereumAddress, type EthereumAsset, type EthereumAssetBalance, type EthereumAssetBalanceError, type EthereumBalanceStage, type EthereumCallError, EthereumClient, type EthereumClientCreationError, type EthereumConfig, type EthereumConfigError, type EthereumConfigInput, type EthereumPortfolioAssetBalance, type EthereumPortfolioChainBalances, type EthereumPortfolioConfigError, type EthereumRpcResolutionError, type EthereumSignatureError, type EthereumTransactionError, type EthereumTransactionOperation, type EvmBlock, type EvmBlockTag, type EvmCallRequest, type EvmCallResult, type EvmCallTransport, type EvmCallTransportFactory, type EvmTransactionRequest, type EvmTransport, type EvmValidationError, GlobalConfig, type GlobalConfigData, type GlobalConfigLoadError, type GlobalConfigLoadOptions, type GlobalConfigSaveError, type GlobalConfigValidationError, type Hex, type HexError, type JsonValue, type LegacyTransaction, type NativeClient, type NativeError, type NativeWallet, type ParsedFlags, type PsbtTextFormat, type ResetGlobalConfigError, type ResetGlobalConfigOptions, type Result, type RpcUrl, type RunCliOptions, type SendErc20Stage, type SendErc20TokenError, type SendErc20TokenInput, type SendErc20TokenResult, type SendNativeEthError, type SendNativeEthInput, type SendNativeEthResult, type SendNativeEthStage, type TokenAmountError, type TransactionHash, type ViemTransportOptions, base64ToBytes, bytesToBase64, bytesToHex, cliVersion, commands, createConfirmationHook, createFileIfAbsent, createViemTransport, decodeErc20Balance, decodeErc20Decimals, defaultGlobalConfigContents, defaultLibraryPath, encodeErc20BalanceOf, encodeErc20DecimalsCall, encodeErc20Transfer, ensureGlobalConfig, err, fileConfigStorage, formatDataOutput, formatExecutionError, formatNativeError, formatPsbt, getEthereumAssetBalance, getEthereumPortfolioBalances, globalConfigPath, helpText, hexToBytes, ok, openNativeClient, parseBytesInput, parseEthereumAsset, parseEthereumConfig, parseEthereumPortfolioConfig, parseEvmCallRequest, parseEvmCallResult, parseFlags, parseGlobalConfigData, parseJsonValue, parseTokenAmount, readInput, resetGlobalConfig, resolveEthereumRpcUrl, runCli, runWithWallet, sendErc20Token, sendNativeEth, serializeSignedTransaction, serializeUnsignedTransaction, terminalConfirmationPrompt };