contracts: Accessors, calls and derivation

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

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

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

export type AddressOnlyContract = ContractAccessor<readonly [
]>;

export type Contract<TAbi extends Abi = Abi> = ContractAccessor<TAbi> & ContractMethods<TAbi>;

export type ContractAccessor<TAbi extends Abi = Abi> = {
    readonly descriptor: ContractDescriptor;
    readonly chain: CanonicalChain;
    readonly address: Address | undefined;
    readonly available: boolean;
    readonly chains: readonly ChainSlug[];
    readonly coverage: ContractCoverage;
    readonly abi: TAbi;
    readonly methods: readonly DescriptorMethod[];
    at(address: Address): Contract<TAbi>;
};

export type ContractMethod<TAbi extends Abi, TName extends ContractFunctionName<TAbi>> = <const TArgs extends ContractFunctionArgs<TAbi, AbiStateMutability, TName> & readonly unknown[]>(...args: TArgs) => ContractCall<TAbi, TName, TArgs>;

export type ContractMethods<TAbi extends Abi> = Abi extends TAbi ? {
    readonly [method: string]: unknown;
} : {
    readonly [N in FunctionNameOf<TAbi> & ContractFunctionName<TAbi>]: ContractMethod<TAbi, N>;
};

export type InterfaceContract<TAbi extends Abi> = ContractAccessor<TAbi>;

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

export type ContractCall<TAbi extends Abi = Abi, TName extends string = string, TArgs = readonly unknown[]> = ContractCallBase & ReadActions<TAbi, TName, TArgs> & (Abi extends TAbi ? WriteActions<TAbi, TName, TArgs> : TName extends NamesOf<TAbi, ReadMutability> ? unknown : WriteActions<TAbi, TName, TArgs>);

export interface ContractCallBase {
    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;
    };
}

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

export interface ReadActions<TAbi extends Abi, TName extends string, TArgs> {
    read(client: Client): Promise<ReadResult<TAbi, TName, TArgs>>;
}

export type ReadResult<TAbi extends Abi, TName extends string, TArgs> = TName extends ContractFunctionName<TAbi> ? TArgs extends ContractFunctionArgs<TAbi, AbiStateMutability, TName> ? ContractFunctionReturnType<TAbi, AbiStateMutability, TName, TArgs> : unknown : unknown;

export interface SauceScriptOptions {
    readonly binding?: string;
}

export interface SimulateOptions {
    readonly account: Account | Address;
    readonly value?: bigint;
}

export type SimulateResult<TAbi extends Abi, TName extends string, TArgs> = TName extends NamesOf<TAbi, WriteMutability> & ContractFunctionName<TAbi, WriteMutability> ? TArgs extends ContractFunctionArgs<TAbi, WriteMutability, TName> ? SimulateContractReturnType<TAbi, TName, TArgs> : SimulateContractReturnType : SimulateContractReturnType;

export interface WriteActions<TAbi extends Abi, TName extends string, TArgs> {
    simulate(client: Client, options: SimulateOptions): Promise<SimulateResult<TAbi, TName, TArgs>>;
    write(client: Client, options?: WriteOptions): Promise<Hash>;
}

export interface WriteOptions {
    readonly account?: Account | Address;
    readonly value?: bigint;
}

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"];

export declare function buildDescriptor(link: ContractLink, protocolInfo: ProtocolInfo, abi: Abi | undefined, deployments?: readonly ChainDeployment[], returns?: ReadonlyMap<string, readonly MethodReturn[]>): ContractDescriptor;

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

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

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

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