@stable-io/cctp-sdk-definitions/dist/layoutItems.d.ts

Definitions for the CCTP SDK

import type { RoTuple } from "@stable-io/map-utils";
import type { Rationalish, Kind, KindWithAtomic, SymbolsOf } from "@stable-io/amount";
import { Rational } from "@stable-io/amount";
import { UniversalAddress } from "./address.js";
import type { Domain, SimplifyDomain } from "./constants/chains/index.js";
import { domains } from "./constants/chains/index.js";
import { DistributiveAmount } from "./constants/kinds.js";
export declare const uint256Item: {
    readonly binary: "uint";
    readonly size: 32;
};
export declare const hashItem: {
    readonly binary: "bytes";
    readonly size: 32;
};
export declare const universalAddressItem: {
    readonly binary: "bytes";
    readonly size: import("@stable-io/utils").Size;
    readonly custom: {
        to: (encoded: Uint8Array) => UniversalAddress;
        from: (addr: UniversalAddress) => Uint8Array<ArrayBufferLike>;
    };
};
export declare const signatureItem: {
    readonly binary: "bytes";
    readonly size: 65;
};
export declare const rawDomainItem: {
    readonly binary: "uint";
    readonly size: 4;
};
export declare const domainItem: <const DT extends RoTuple<Domain> = typeof domains>(domainTuple?: DT) => {
    readonly custom: {
        to: (val: number) => SimplifyDomain<DT[number]>;
        from: (val: SimplifyDomain<DT[number]>) => number;
    };
    readonly binary: "uint";
    readonly size: 4;
};
export declare const fixedDomainItem: <const D extends Domain>(domain: D) => {
    readonly custom: {
        to: D;
        from: {
            readonly Ethereum: 0;
            readonly Avalanche: 1;
            readonly Optimism: 2;
            readonly Arbitrum: 3;
            readonly Noble: 4;
            readonly Solana: 5;
            readonly Base: 6;
            readonly Polygon: 7;
            readonly Sui: 8;
            readonly Aptos: 9;
            readonly Unichain: 10;
            readonly Linea: 11;
            readonly Codex: 12;
            readonly Sonic: 13;
            readonly Worldchain: 14;
        }[D extends bigint ? `bigint(${D})` : D extends boolean ? `boolean(${D})` : D];
    };
    readonly binary: "uint";
    readonly size: 4;
};
type NumberType<S extends number> = S extends 1 | 2 | 3 | 4 | 5 | 6 ? number : bigint;
type AmountReturnItem<S extends number, K extends Kind> = {
    binary: "uint";
    size: S;
    custom: {
        to: (val: NumberType<S>) => DistributiveAmount<K>;
        from: (amount: DistributiveAmount<K>) => NumberType<S>;
    };
};
type TransformFunc<S extends number> = {
    to: (val: NumberType<S>) => Rationalish;
    from: (val: Rational) => number | bigint;
};
export declare function amountItem<S extends number, const K extends KindWithAtomic>(size: S, kind: K, unitSymbol?: SymbolsOf<K>, transform?: TransformFunc<S>): AmountReturnItem<S, K>;
export declare function amountItem<S extends number, const K extends Kind>(size: S, kind: K, unitSymbol: SymbolsOf<K>, transform?: TransformFunc<S>): AmountReturnItem<S, K>;
export {};
//# sourceMappingURL=layoutItems.d.ts.map