contracts: Accessors, calls and derivation

import { contracts } from "@eco-incorp/sauce";

export declare function buildDescriptor(link: ContractLink, protocolInfo: ProtocolInfo, abi: Abi | undefined): ContractDescriptor;

export declare function buildMethods(abi: Abi): DescriptorMethod[];

export declare function buildPerChainAddress(chains: readonly ChainDeployment[], roleKey: string | undefined): Record<number, Address>;

export declare function deriveChainSlugs(perChainAddress: Readonly<Record<number, Address>>): ChainSlug[];

export declare function deriveContractName(protocolName: string, abiExport: string): string;

export declare function chainContracts(chainRef: ChainRef): ChainContracts;

export declare function on(chainRef: ChainRef): ChainContracts;

export type ChainContracts = {
    readonly [P in ProtocolSlug as PascalOf<P>]: {
        readonly [C in ContractNameOf<P>]: ContractAccessor;
    };
} & {
    readonly [F in FamilyKey]: {
        readonly [C in FamilyContracts<F>]: ContractAccessor;
    };
};

export interface ContractAccessor {
    readonly descriptor: ContractDescriptor;
    readonly chain: CanonicalChain;
    readonly address: Address | undefined;
    readonly available: boolean;
    readonly chains: readonly ChainSlug[];
    readonly coverage: ContractCoverage;
    readonly abi: Abi;
    readonly methods: readonly DescriptorMethod[];
    at(address: Address): ContractAccessor;
    readonly [method: string]: unknown;
}

export declare function makeContractCall(descriptor: ContractDescriptor, chain: CanonicalChain, address: Address, method: DescriptorMethod, args: readonly unknown[]): ContractCall;

CONTRACT_BASE_DIRS: readonly string[]

export interface ContractCall {
    readonly chain: CanonicalChain;
    readonly protocol: string;
    readonly contract: string;
    readonly address: Address;
    readonly method: DescriptorMethod;
    readonly args: readonly unknown[];
    readonly fidelity: "exact" | "widened";
    readonly caveats: readonly string[];
    readonly data: Hex;
    encode(opts?: EncodeOptions): Hex;
    toCall(opts?: EncodeOptions): {
        readonly target: Address;
        readonly data: Hex;
        readonly value: bigint;
    };
    toSauceScript(opts?: SauceScriptOptions): {
        readonly imports: readonly string[];
        readonly statement: string;
        readonly source: string;
        readonly baseDirs: readonly string[];
    };
}

export interface EncodeOptions {
    readonly allowWidened?: boolean;
    readonly value?: bigint;
}

export interface SauceScriptOptions {
    readonly binding?: string;
}

export type ContractNameOf<P extends ProtocolSlug> = LinkOf<P>["contract"];

export type FamilyContracts<F extends FamilyKey> = {
    [N in FamilyLinksOf<F>["contract"]]: IsUnion<Extract<FamilyLinksOf<F>, {
        contract: N;
    }>["protocol"]> extends true ? never : N;
}[FamilyLinksOf<F>["contract"]];

export type FamilyKey = {
    [P in ProtocolSlug]: FamilyOf<P>;
}[ProtocolSlug];

export type FamilyOf<P extends ProtocolSlug> = StripV<P> extends never ? never : PascalOf<StripV<P>>;

export type ProtocolNamespaceKey = PascalOf<ProtocolSlug>;

export type ProtocolSlug = Links["protocol"];