micro-sol-signer/idl/index.d.ts

Create, sign & decode Solana transactions with minimum deps

import * as P from 'micro-packed';
import type { Instruction } from '../index.ts';
export declare const PRECISION = 9;
export declare const Decimal: P.Coder<bigint, string>;
export type Bytes = Uint8Array;
export declare const shortU16: P.CoderType<number>;
export declare const pubKey: P.CoderType<string>;
export declare function isOnCurve(bytes: Bytes | string): boolean;
export declare function programAddress(program: string, ...seeds: Bytes[]): string;
type ArrLike<T> = Array<T> | ReadonlyArray<T>;
type Node<K extends string, F = {}> = {
    readonly kind: K;
} & F;
type NumberValue = Node<'numberValueNode', {
    readonly number: number;
}>;
type NoneValue = Node<'noneValueNode'>;
type BytesValue = Node<'bytesValueNode', {
    readonly data: string;
    readonly encoding: 'base16' | 'base58' | 'base64' | 'utf8';
}>;
type BooleanValue = Node<'booleanValueNode', {
    readonly boolean: boolean;
}>;
type AccountBumpValue = Node<'accountBumpValueNode', {
    readonly name: string;
}>;
type PublicKeyValue = Node<'publicKeyValueNode', {
    readonly publicKey: string;
}>;
type PayerValue = Node<'payerValueNode'>;
type PdaLink = Node<'pdaLinkNode', {
    readonly name: string;
}>;
type PdaSeedValue = Node<'pdaSeedValueNode', {
    readonly name: string;
    readonly value: Node<'accountValueNode' | 'argumentValueNode', {
        readonly name: string;
    }>;
}>;
type PdaValue = Node<'pdaValueNode', {
    readonly pda: PdaLink;
    readonly seeds: ArrLike<PdaSeedValue>;
}>;
type IdentityValue = Node<'identityValueNode'>;
type AccountValue = Node<'accountValueNode', {
    readonly name: 'authority';
}>;
type DefaultValue = NumberValue | NoneValue | AccountBumpValue | BytesValue | BooleanValue | PublicKeyValue | PayerValue | PdaValue | IdentityValue | AccountValue;
type DefaultValueMap = {
    boolean: BooleanValue;
    number: NumberValue;
    bytes: BytesValue;
    none: NoneValue;
    publicKey: PublicKeyValue;
    payer: PayerValue;
    pda: PdaValue;
    identity: IdentityValue;
    account: AccountValue;
};
type DefaultValueDef<T extends keyof DefaultValueMap> = {
    defaultValue?: DefaultValueMap[T];
    defaultValueStrategy?: 'omitted' | 'optional';
};
declare const IGNORE_DEFAULT: readonly ["payerValueNode", "accountBumpValueNode", "identityValueNode", "pdaValueNode"];
type FieldDiscriminator = Node<'fieldDiscriminatorNode', {
    readonly name: string;
    readonly offset: number;
}>;
type SizeDiscriminator = Node<'sizeDiscriminatorNode', {
    readonly size: number;
}>;
type ConstantDiscriminator = Node<'constantDiscriminatorNode', {
    readonly offset: number;
    readonly constant: ConstantType;
}>;
type Discriminator = SizeDiscriminator | FieldDiscriminator | ConstantDiscriminator;
declare const NumCoders: {
    readonly shortU16: {
        readonly le: P.CoderType<number>;
        readonly be: P.CoderType<number>;
        readonly bigint: false;
    };
    readonly u8: {
        readonly le: P.CoderType<number>;
        readonly be: P.CoderType<number>;
        readonly bigint: false;
    };
    readonly u16: {
        readonly le: P.CoderType<number>;
        readonly be: P.CoderType<number>;
        readonly bigint: false;
    };
    readonly u32: {
        readonly le: P.CoderType<number>;
        readonly be: P.CoderType<number>;
        readonly bigint: false;
    };
    readonly u64: {
        readonly le: P.CoderType<bigint>;
        readonly be: P.CoderType<bigint>;
        readonly bigint: true;
    };
    readonly u128: {
        readonly le: P.CoderType<bigint>;
        readonly be: P.CoderType<bigint>;
        readonly bigint: true;
    };
    readonly i8: {
        readonly le: P.CoderType<number>;
        readonly be: P.CoderType<number>;
        readonly bigint: false;
    };
    readonly i16: {
        readonly le: P.CoderType<number>;
        readonly be: P.CoderType<number>;
        readonly bigint: false;
    };
    readonly i32: {
        readonly le: P.CoderType<number>;
        readonly be: P.CoderType<number>;
        readonly bigint: false;
    };
    readonly i64: {
        readonly le: P.CoderType<bigint>;
        readonly be: P.CoderType<bigint>;
        readonly bigint: true;
    };
    readonly i128: {
        readonly le: P.CoderType<bigint>;
        readonly be: P.CoderType<bigint>;
        readonly bigint: true;
    };
    readonly f32: {
        readonly le: P.CoderType<number>;
        readonly be: P.CoderType<number>;
        readonly bigint: false;
    };
    readonly f64: {
        readonly le: P.CoderType<number>;
        readonly be: P.CoderType<number>;
        readonly bigint: false;
    };
};
type BigIntCoders = {
    [K in keyof typeof NumCoders]: (typeof NumCoders)[K]['bigint'] extends true ? K : never;
}[keyof typeof NumCoders];
type NumericType = Node<'numberTypeNode', {
    readonly format: 'shortU16' | keyof typeof NumCoders;
    readonly endian?: 'le' | 'be';
}> & DefaultValueDef<'number'>;
type GetTypeNumeric<T extends NumericType> = T['format'] extends BigIntCoders ? bigint : number;
type CountType = Node<'prefixedCountNode', {
    prefix: NumericType;
}> | Node<'remainderCountNode'> | Node<'fixedCountNode', {
    value: number;
}>;
type EnumVariants = (Node<'enumEmptyVariantTypeNode'> | Node<'enumStructVariantTypeNode', {
    readonly struct: any;
}> | Node<'enumTupleVariantTypeNode', {
    readonly tuple: TupleType;
}>) & {
    readonly name: string;
    readonly discriminator?: number;
};
type EnumType = Node<'enumTypeNode', {
    readonly variants: ArrLike<EnumVariants>;
    readonly size: NumericType;
}>;
type ArrayType = Node<'arrayTypeNode', {
    readonly item: BasicType;
    readonly count: CountType;
}>;
type PublicKeyType = Node<'publicKeyTypeNode'>;
type TypeLinkType = Node<'definedTypeLinkNode', {
    readonly name: string;
}>;
type BooleanType = Node<'booleanTypeNode', {
    readonly size: NumericType;
}> & DefaultValueDef<'boolean'>;
type StringType = Node<'stringTypeNode'>;
type StructField = Node<'structFieldTypeNode', {
    readonly name: string;
    readonly type: BasicType;
}> & DefaultValueDef<any>;
type StructType = Node<'structTypeNode', {
    readonly fields: ArrLike<StructField>;
}>;
type OptionalType = Node<'optionTypeNode', {
    readonly item: BasicType;
    readonly prefix?: NumericType;
    readonly fixed?: boolean;
}>;
type AmountType = Node<'amountTypeNode', {
    readonly decimals: number;
    readonly unit: string;
    readonly number: NumericType;
}>;
type FixedSizeType = Node<'fixedSizeTypeNode', {
    readonly size: number;
    readonly type: BasicType;
}>;
type BytesType = Node<'bytesTypeNode'>;
type PrefixType = Node<'sizePrefixTypeNode', {
    readonly type: BasicType;
    readonly prefix: NumericType;
}>;
type ZeroableType = Node<'zeroableOptionTypeNode', {
    readonly item: BasicType;
}>;
type RemainderOptionType = Node<'remainderOptionTypeNode', {
    readonly item: BasicType;
}>;
type HiddenPrefixType = Node<'hiddenPrefixTypeNode', {
    readonly type: BasicType;
    readonly prefix: ArrLike<BasicType>;
}>;
type HiddenSuffixType = Node<'hiddenSuffixTypeNode', {
    readonly type: BasicType;
    readonly suffix: ArrLike<BasicType>;
}>;
type ConstantType = Node<'constantValueNode', {
    readonly type: BasicType;
    readonly value: any;
}>;
type PreOffsetType = Node<'preOffsetTypeNode', {
    readonly offset: number;
    readonly strategy: 'padded' | 'absolute' | 'relative';
    readonly type: BasicType;
}>;
type PostOffsetType = Node<'PostOffsetTypeNode', {
    readonly offset: number;
    readonly strategy: 'padded' | 'absolute' | 'relative';
    readonly type: BasicType;
}>;
type TupleType = Node<'tupleTypeNode', {
    readonly items: ArrLike<BasicType>;
}>;
type MapType = Node<'mapTypeNode', {
    readonly key: BasicType;
    readonly value: BasicType;
    readonly count: CountType;
}>;
type BasicType = (EnumType | NumericType | OptionalType | StructType | ArrayType | PublicKeyType | TypeLinkType | StringType | BooleanType | AmountType | FixedSizeType | BytesType | ZeroableType | PrefixType | RemainderOptionType | ConstantType | PreOffsetType | StructField | HiddenPrefixType | HiddenSuffixType | PostOffsetType | TupleType | MapType) & {
    defaultValue?: DefaultValue;
    defaultValueStrategy?: 'omitted' | 'optional';
};
type DefinedTypes = Record<string, P.CoderType<any>>;
type GetTypeStruct<T extends StructType, DT extends DefinedTypes = {}> = {
    [K in T['fields'][number]['name']]: GetType<Extract<T['fields'][number], {
        name: K;
    }>['type'], DT>;
};
type GetTypeTuple<T extends TupleType, DT extends DefinedTypes = {}> = T['items'] extends readonly [
    infer A
] ? [A extends BasicType ? GetType<A, DT> : never] : T['items'] extends readonly [infer A, infer B] ? [A extends BasicType ? GetType<A, DT> : never, B extends BasicType ? GetType<B, DT> : never] : T['items'] extends readonly [infer A, infer B, infer C] ? [
    A extends BasicType ? GetType<A, DT> : never,
    B extends BasicType ? GetType<B, DT> : never,
    C extends BasicType ? GetType<C, DT> : never
] : T['items'] extends ReadonlyArray<infer Item> ? (Item extends BasicType ? GetType<Item, DT> : never)[] : never[];
type GetTypeEnum<T extends EnumType, DT extends DefinedTypes = {}> = T['variants'] extends readonly [] ? never : T['variants'][number] extends infer Variant ? Variant extends Node<'enumEmptyVariantTypeNode'> & {
    readonly name: infer Name;
} ? {
    TAG: Name extends string ? Name : never;
} : Variant extends Node<'enumStructVariantTypeNode'> & {
    readonly name: infer Name;
    readonly struct: infer Struct;
} ? {
    TAG: Name extends string ? Name : never;
    data: Struct extends StructType ? GetTypeStruct<Struct, DT> : never;
} : Variant extends Node<'enumTupleVariantTypeNode'> & {
    readonly name: infer Name;
    readonly tuple: infer Tuple;
} ? {
    TAG: Name extends string ? Name : never;
    data: Tuple extends TupleType ? GetTypeTuple<Tuple, DT> : never;
} : never : never;
type GetTypeLink<T extends TypeLinkType, DT extends DefinedTypes = {}> = T['name'] extends keyof DT ? P.UnwrapCoder<DT[T['name']]> : never;
type GetTypeBase<T extends BasicType, DT extends DefinedTypes = {}> = T extends NumericType ? GetTypeNumeric<T> : T extends BooleanType ? boolean : T extends StringType ? string : T extends AmountType ? string : T extends BytesType ? Uint8Array : T extends PublicKeyType ? string : T extends ArrayType ? (GetType<T['item'], DT>)[] : T extends MapType ? Map<GetType<T['key'], DT>, GetType<T['value'], DT>> : T extends StructType ? GetTypeStruct<T, DT> : T extends TupleType ? GetTypeTuple<T, DT> : T extends EnumType ? GetTypeEnum<T, DT> : T extends TypeLinkType ? GetTypeLink<T, DT> : T extends FixedSizeType ? GetType<T['type'], DT> : T extends HiddenPrefixType ? GetType<T['type'], DT> : T extends HiddenSuffixType ? GetType<T['type'], DT> : T extends PreOffsetType ? GetType<T['type'], DT> : T extends PostOffsetType ? GetType<T['type'], DT> : T extends ZeroableType ? GetType<T['item'], DT> : T extends PrefixType ? GetType<T['type'], DT> : T extends ConstantType ? GetType<T['type'], DT> : T extends RemainderOptionType ? GetType<T['item'], DT> | undefined : T extends OptionalType ? GetType<T['item'], DT> | undefined : unknown;
export type GetType<T extends BasicType, DT extends DefinedTypes = {}> = T extends {
    defaultValue: Exclude<DefaultValue, {
        kind: (typeof IGNORE_DEFAULT)[number];
    }>;
    defaultValueStrategy?: infer Strategy;
} ? Strategy extends 'omitted' ? undefined : Strategy extends 'optional' | undefined ? GetTypeBase<T, DT> | undefined : GetTypeBase<T, DT> : GetTypeBase<T, DT>;
export declare function mapType<T extends BasicType, DT extends DefinedTypes>(type: T, dt: DT): GetType<T, DT>;
type DefinedType = {
    readonly kind: 'definedTypeNode';
    readonly name: string;
    readonly type: BasicType;
};
export type GetDefinedTypes<T extends ArrLike<DefinedType>> = {
    [K in T[number]['name']]: P.CoderType<GetType<Extract<T[number], {
        name: K;
    }>['type']>>;
};
type PDASeeds = Node<'variablePdaSeedNode', {
    readonly name: string;
    readonly type: BasicType;
}> | Node<'constantPdaSeedNode', {
    readonly name: string;
    readonly type: BasicType;
    readonly value: DefaultValue;
}>;
type PDAType = Node<'pdaNode', {
    readonly name: string;
    readonly seeds: ArrLike<PDASeeds>;
}>;
type GetPDASeeds<T extends PDAType, DT extends DefinedTypes = {}> = {
    [K in Extract<T['seeds'][number], {
        name: string;
    }>['name']]: Extract<T['seeds'][number], {
        name: K;
    }> extends Node<'variablePdaSeedNode', {
        readonly type: infer Type;
    }> ? GetType<Type & BasicType, DT> : Extract<T['seeds'][number], {
        name: K;
    }> extends Node<'constantPdaSeedNode', {
        readonly type: infer Type;
    }> ? GetType<Type & BasicType, DT> : never;
};
type PDAs<T extends ArrLike<PDAType>, DT extends DefinedTypes = {}> = {
    [K in T[number]['name']]: (value: GetPDASeeds<Extract<T[number], {
        name: K;
    }>, DT>) => string;
};
export declare function parsePDAs<T extends ArrLike<PDAType>, DT extends DefinedTypes = {}>(program: string, pda: T, dt?: DT): PDAs<T, DT>;
type Account = Node<'instructionAccountNode', {
    readonly name: string;
    readonly isWritable: boolean;
    readonly isSigner: boolean | 'either';
    readonly isOptional: boolean;
}> & DefaultValueDef<'publicKey' | 'pda' | 'identity' | 'payer' | 'account'>;
type Argument = Node<'instructionArgumentNode', {
    readonly name: string;
    readonly type: BasicType;
}> & DefaultValueDef<any>;
type GetArgumentType<A extends Argument, DT extends DefinedTypes = {}> = A extends {
    type: infer T extends BasicType;
    defaultValue: infer DV;
    defaultValueStrategy: infer DVS;
} ? GetType<{
    defaultValue: DV;
    defaultValueStrategy: DVS;
} & T, DT> : A extends {
    type: infer T extends BasicType;
    defaultValue: infer DV;
} ? GetType<{
    defaultValue: DV;
    defaultValueStrategy: undefined;
} & T, DT> : A extends {
    type: infer T extends BasicType;
} ? GetType<T, DT> : unknown;
export type GetTypeArguments<T extends ArrLike<Argument>, DT extends DefinedTypes = {}> = {
    [K in Extract<T[number], {
        name: string;
    }>['name']]: GetArgumentType<Extract<T[number], {
        name: K;
    }>, DT>;
};
type RemainingAccounts = Node<'instructionRemainingAccountsNode', {
    readonly value: Node<'argumentValueNode', {
        readonly name: string;
    }>;
}>;
type ProgramInstruction = Node<'instructionNode', {
    readonly accounts: ArrLike<Account>;
    readonly arguments: ArrLike<Argument>;
    readonly discriminators?: ArrLike<Discriminator>;
    readonly remainingAccounts?: ArrLike<RemainingAccounts>;
    readonly name: string;
    readonly optionalAccountStrategy?: 'programId' | 'omitted';
}>;
export type GetTypeAccounts<T extends ArrLike<Account>> = {
    [K in Extract<T[number], {
        name: string;
    }>['name']]: Extract<T[number], {
        name: K;
    }> extends {
        defaultValue?: {
            kind: 'publicKeyValueNode';
        };
    } ? undefined : string;
};
export type Nullable<T> = {
    [K in keyof T as undefined extends T[K] ? never : K]: T[K];
} & {
    [K in keyof T as undefined extends T[K] ? K : never]?: Exclude<T[K], undefined>;
};
export type GetInstructionArgs<T extends ProgramInstruction, DT extends DefinedTypes = {}> = Nullable<GetTypeArguments<T['arguments'], DT> & GetTypeAccounts<T['accounts']>>;
type DecodedInstruction<T extends ProgramInstruction, DT extends DefinedTypes = {}> = {
    TAG: string;
    data: GetInstructionArgs<T, DT> & {
        [K in Extract<T['accounts'][number], {
            name: string;
        }>['name']]?: string;
    };
};
export type ParsedInstructions<T extends ArrLike<ProgramInstruction>, DT extends DefinedTypes = {}> = {
    encoders: {
        [K in T[number]['name']]: (inst: GetInstructionArgs<Extract<T[number], {
            name: K;
        }>, DT>) => Instruction;
    };
    decoder: (inst: Instruction, opts?: P.ReaderOpts) => DecodedInstruction<T[number], DT>;
};
type ContractAccount = {
    readonly kind: 'accountNode';
    readonly name: string;
    readonly data: BasicType;
    readonly discriminators?: ArrLike<Discriminator>;
};
type DecodedAccount<T extends ArrLike<ContractAccount>, DT extends DefinedTypes = {}> = {
    [K in T[number]['name']]: {
        TAG: K;
        data: GetType<Extract<T[number], {
            name: K;
        }>['data'], DT>;
    };
}[T[number]['name']];
export type AccountDefinitions<T extends ArrLike<ContractAccount>, DT extends DefinedTypes = {}> = {
    coders: {
        [K in T[number]['name']]: P.CoderType<GetType<Extract<T[number], {
            name: K;
        }>['data'], DT>>;
    };
    decoder: (data: Uint8Array, opts?: P.ReaderOpts) => DecodedAccount<T, DT>;
};
export declare function defineAccounts<T extends ArrLike<ContractAccount>, DT extends DefinedTypes>(accounts: T, types: DT): AccountDefinitions<T, DT>;
type Program = {
    readonly kind: 'programNode';
    readonly name: string;
    readonly publicKey: string;
    readonly definedTypes: ArrLike<DefinedType>;
    readonly pdas: ArrLike<PDAType>;
    readonly instructions: ArrLike<ProgramInstruction>;
    readonly accounts: ArrLike<ContractAccount>;
};
type GetTypeProgram<P extends Program> = {
    name: P['name'];
    contract: P['publicKey'];
    types: GetDefinedTypes<P['definedTypes']>;
    pdas: PDAs<P['pdas'], GetDefinedTypes<P['definedTypes']>>;
    instructions: ParsedInstructions<P['instructions'], GetDefinedTypes<P['definedTypes']>>;
    accounts: AccountDefinitions<P['accounts'], GetDefinedTypes<P['definedTypes']>>;
};
export declare function defineProgram<P extends Program>(p: P): GetTypeProgram<P>;
type IDL = {
    readonly kind: 'rootNode';
    readonly program: Program;
    readonly additionalPrograms: ArrLike<Program>;
};
type GetTypeIDL<T extends IDL> = {
    [P in T['program']['name']]: {
        program: GetTypeProgram<T['program']>;
        additionalPrograms: {
            [K in T['additionalPrograms'][number]['name']]: GetTypeProgram<Extract<T['additionalPrograms'][number], {
                name: K;
            }>>;
        };
    };
};
export declare function defineIDL<T extends IDL>(idl: T): GetTypeIDL<T>;
export {};
//# sourceMappingURL=index.d.ts.map