/**
 * Which account a live tick runs against.
 *
 * Executing a scanner needs an account identity — it is handed to the exchange reads the scanner
 * makes. But during authoring no account exists yet: the wallet is created when the strategy is
 * funded, which is deliberately after validation. So one is resolved rather than required.
 */
/**
 * The stand-in used when no real account is available.
 *
 * Faithful rather than a workaround: an account with no history returns an empty book, which is
 * exactly what a freshly funded strategy sees on its first tick. A scanner that breaks on an empty
 * position list is broken, and would break identically in production — catching that is the point.
 * The deploy preflight already validates against this same address for the same reason.
 */
export declare const PLACEHOLDER_ADDRESS = "0x0000000000000000000000000000000000000000";
export type WalletSource = 
/** Named on the command line. */
"explicit"
/** The recipe's own wallet, when it resolved to a real address. */
 | "recipe"
/** A default configured for this machine. */
 | "environment"
/** The stand-in. */
 | "placeholder";
export interface ResolvedWallet {
    address: string;
    source: WalletSource;
    /** What the account's state implies about what a passing run establishes. */
    book: "real" | "empty";
}
export interface WalletInputs {
    /** From `--wallet`. */
    explicit?: string;
    /** `strategy.wallet` after environment substitution — often still a placeholder. */
    fromRecipe?: string;
    /** A machine-level default. */
    fromEnvironment?: string;
}
/**
 * Resolve in order of specificity.
 *
 * The recipe's own wallet is preferred over any default because validating an edit to a deployed
 * strategy against its real positions is more faithful than forcing a cold start. It is accepted
 * only when it *looks* like an address: an unresolved placeholder is a non-empty string that the
 * schema accepts happily, and passing that to the exchange would produce a confusing failure well
 * away from its cause.
 */
export declare function resolveWallet(inputs: WalletInputs): ResolvedWallet;
/** Whether a supplied address is well formed. Checked before anything runs. */
export declare function isWellFormedAddress(value: string): boolean;
/**
 * What running against this account does and does not establish.
 *
 * Rides the result so a caller cannot report more confidence than the run earned. Against an empty
 * book, logic that depends on open positions never executes — which is correct for a strategy about
 * to be funded, and worth saying out loud rather than leaving to inference.
 */
export declare function walletClaim(wallet: ResolvedWallet): {
    proves: string;
    doesNotProve: string[];
};
//# sourceMappingURL=wallet.d.ts.map