svm venues: shared helpers

export declare function ceilDiv(a: bigint, b: bigint): bigint;

export declare function readUintLE(data: Uint8Array, offset: number, width: number): bigint;

export declare function assertOracleExponent(provider: OracleExponentProvider, expo: number, context: string): void;

export type OracleExponentProvider = "pyth-price-update-v2" | "pyth-v2-price-account";

PYTH_MAX_NUM_DECIMALS = 12

export interface OracleExponentRange {
    readonly min: number;
    readonly max: number;
    readonly provenance: string;
}

ORACLE_EXPONENT_RANGES: Readonly<Record<OracleExponentProvider, OracleExponentRange>>

export declare function configurePdaMemo(config: PdaMemoConfig): void;

export declare function getPdaMemoMaxEntries(): number;

DEFAULT_PDA_MEMO_MAX_ENTRIES = 100000

export interface PdaMemoConfig {
    maxEntries: number;
}

export declare function listVenues(): string[];

export declare function venueAdapter(slug: string): SvmVenueAdapter;

export type RegisteredVenueSlug = keyof typeof adaptersTyped;

TOKEN_PROGRAM: Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">

TOKEN_2022_PROGRAM: Address<"TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb">

ASSOCIATED_TOKEN_PROGRAM: Address<"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL">

SYSTEM_PROGRAM: Address<"11111111111111111111111111111111">

SCALE_AMM_PROGRAM_ID: Address<"SCALEwAvEK5gtkdHiFzXfPgtk2YwJxPDzaV3aDmR7tA">

SCALE_VMM_PROGRAM_ID: Address<"SCALEWoRSpVZpMRqHEcDfNvBh3nUSe34jDr9r689gLa">

BUY_DISCRIMINATOR: Uint8Array<ArrayBuffer>

SELL_DISCRIMINATOR: Uint8Array<ArrayBuffer>

FEE_BENEFICIARY_SLOTS = 5

CONFIG_SEED: Uint8Array<ArrayBuffer>

POOL_SEED: Uint8Array<ArrayBuffer>

CURVE_CONSTANT_PRODUCT = 0

SCALE_CURVE_HELPER_NAME = "qScaleCurve"

SCALE_CURVE_HELPER_SOURCE: string

export declare function readUintLE(data: Uint8Array, offset: number, width: number): bigint;

export declare function pubkeyAt(data: Uint8Array, offset: number): Address;

export declare function readFeeBeneficiaries(data: Uint8Array, offset: number): FeeBeneficiary[];

export declare function ata(owner: Address, mint: Address, tokenProgram: Address): Promise<Address>;

export declare function detectTokenProgram(mint: Address, data: Uint8Array, owner?: Address): Address;

export declare function computeScaleQuote(state: ScaleCurveState, amountIn: bigint, direction: ScaleDirection): bigint;

export declare function scaleDepthReserves(state: ScaleCurveState, direction: ScaleDirection): {
    reserveIn: bigint;
    reserveOut: bigint;
};

export declare function scaleContinuousFees(state: ScaleCurveState, direction: ScaleDirection): {
    gammaPpm: bigint;
    muPpm: bigint;
};

declare function pda(seeds: (Address | Uint8Array)[], programAddress: Address): Promise<Address>;

export interface FeeBeneficiary {
    wallet: Address;
    shareBps: number;
}

export type ScaleDirection = "aToB" | "bToA";

export interface ScaleCurveState {
    reservesA: bigint;
    reservesB: bigint;
    shift: bigint;
    platformFeeBps: bigint;
    shareBps: readonly bigint[];
}

export declare function mulDivDown(a: bigint, n: bigint, d: bigint): bigint;

export declare function mulDivUp(a: bigint, n: bigint, d: bigint): bigint;

export declare function divUpRaw(a: bigint, d: bigint): bigint;

export declare function mulDown(a: bigint, b: bigint): bigint;

export declare function mulUp(a: bigint, b: bigint): bigint;

export declare function divDown(a: bigint, b: bigint): bigint;

export declare function divUp(a: bigint, b: bigint): bigint;

export declare function complement(a: bigint): bigint;

export declare function calcWrappedAmount(amount: bigint, token: StabbleTokenScale): bigint;

export declare function calcUnwrappedAmount(amount: bigint, token: StabbleTokenScale): bigint;

export declare function calcRoundedAmount(amount: bigint, token: StabbleTokenScale): bigint;

export declare function decodeStabbleVault(pool: Address, data: Uint8Array | null): StabbleVaultInfo;

export declare function decodeStabblePoolCommon(pool: Address, data: Uint8Array | null, programLabel: string, tokensOffset: number, tokenSize: number, weighted: boolean, minLength: number): {
    vault: Address<string>;
    mint: Address<string>;
    authorityBump: number;
    isActive: boolean;
    tokens: (StabblePoolTokenBase & {
        weight?: bigint;
    })[];
};

export declare function createProgramAddress(seeds: Uint8Array[], programId: Address): Address;

export declare function deriveStabbleVaultAuthority(vault: Address, authorityBump: number): Address;

export declare function findStabbleAta(owner: Address, mint: Address): Promise<Address>;

export declare function stableCalcInvariantN(amplification: bigint, balances: readonly bigint[]): bigint;

export declare function stableGetBalanceGivenInvariant(amplification: bigint, balances: readonly bigint[], invariant: bigint, excludedBalance: bigint): bigint;

export declare function stableGetBalanceGivenInvariantWarm(amplification: bigint, balances: readonly bigint[], invariant: bigint, excludedBalance: bigint, y0: bigint): bigint;

export declare function stableCalcOutGivenIn(amplification: bigint, balances: readonly bigint[], tokenIndexIn: number, tokenIndexOut: number, amountIn: bigint, invariant: bigint): bigint;

export declare function stableGetAmplification(ampInitialFactor: number, ampTargetFactor: number, rampStartTs: bigint, rampStopTs: bigint, currentTs: bigint): bigint;

export declare function stableDHelperSource(n: number): {
    name: string;
    source: string;
};

export declare function stableYWarmHelperSource(n: number): {
    name: string;
    source: string;
};

export declare function stableQuoteHelperSource(n: number): {
    name: string;
    source: string;
};

export declare function isqrtFloor(n: bigint): bigint;

export declare function weightedPowUp(base: bigint, exponent: bigint): bigint;

export declare function weightedCalcOutGivenIn(balanceIn: bigint, weightIn: bigint, balanceOut: bigint, weightOut: bigint, amountIn: bigint): bigint | null;

export declare function weightedPowUpSource(weightIn: bigint, weightOut: bigint, baseVar: string, out: string): string[];

export declare function weightedCoreQuoteLines(tag: string, balInVar: string, balOutVar: string, weightIn: bigint, weightOut: bigint, wrappedXExpr: string, outVar: string): string[];

STABLE_SWAP_PROGRAM_ID: Address<"swapNyd8XiQwJ6ianp9snpu4brUqFxadzvHebnAXjJZ">

WEIGHTED_SWAP_PROGRAM_ID: Address<"swapFpHZwjELNnjvThjajtiVmkz3yPQEHjLtka2fwHW">

STABBLE_VAULT_PROGRAM_ID: Address<"vo1tWgqZMjG61Z2T9qUaMYKqZ75CYzMuaZ2LZP1n7HV">

STABBLE_TOKEN_PROGRAM_ID: Address<"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA">

STABBLE_TOKEN_2022_PROGRAM_ID: Address<"TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb">

STABBLE_ATA_PROGRAM_ID: Address<"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL">

STABBLE_POOL_DISCRIMINATOR: Uint8Array<ArrayBuffer>

STABBLE_VAULT_DISCRIMINATOR: Uint8Array<ArrayBuffer>

STABBLE_SWAP_DISCRIMINATOR: Uint8Array<ArrayBuffer>

STABBLE_ONE = 1000000000n

export interface StabbleTokenScale {
    scalingUp: boolean;
    scalingFactor: bigint;
}

export interface StabblePoolTokenBase {
    mint: Address;
    decimals: number;
    scalingUp: boolean;
    scalingFactor: bigint;
    balance: bigint;
}

export interface StabbleVaultInfo {
    admin: Address;
    withdrawAuthority: Address;
    withdrawAuthorityBump: number;
    authorityBump: number;
    isActive: boolean;
    beneficiary: Address;
    beneficiaryFee: bigint;
}

declare function assertU64AmountIn(amountIn: bigint, label: string): void;

U64_MAX: bigint

STABLE_AMP_PRECISION = 1000n

STABLE_MIN_TOKENS = 2

STABLE_MAX_TOKENS = 5

WEIGHTED_MAX_IN_RATIO = 300000000n

WEIGHTED_MIN_TOKENS = 2

WEIGHTED_MAX_TOKENS = 4

export declare function calcRoundedAmount(amount: bigint, token: StabbleTokenScale): bigint;

export interface SvmHelperFn {
    name: string;
    source: string;
}

export type AccountLoader = (address: Address) => Promise<Uint8Array | null>;

export type OwnedAccountLoader = (address: Address) => Promise<{
    data: Uint8Array;
    owner: Address;
} | null>;

export type AccountBytesMap = Record<string, Uint8Array>;

export interface PoolConfig {
    venue: string;
    pool: Address;
}

export interface VenueAccount {
    ref: string;
    address?: Address;
    writable?: boolean;
    signer?: boolean;
    optional?: boolean;
}

export interface SwapUser {
    outAta: string;
    inAta: string;
    owner: string;
}

export interface VenueSwap {
    programId: Address;
    data: Uint8Array;
    accounts: VenueAccount[];
}

export interface SvmVenueAdapter {
    slug: string;
    kind: "constant-product" | "stable" | "sqrt-price";
    programId: Address;
    fetchPoolConfig(load: AccountLoader, pool: Address): Promise<PoolConfig>;
    quoteAccounts(cfg: PoolConfig): VenueAccount[];
    emitQuote(cfg: PoolConfig, i: number, amountIn: bigint): string;
    buildSwap(cfg: PoolConfig, user: SwapUser, amountIn: bigint): VenueSwap;
    referenceQuote(cfg: PoolConfig, state: AccountBytesMap, amountIn: bigint, now: bigint): bigint;
}