@aragon/gov-ui-kit 1.26.0 → 1.27.0

package/dist/types/node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/PublicKey.d.ts

@@ -0,0 +1,308 @@
+import * as Bytes from './Bytes.js';
+import * as Errors from './Errors.js';
+import * as Hex from './Hex.js';
+import type { Compute, ExactPartial } from './internal/types.js';
+/** Root type for an ECDSA Public Key. */
+export type PublicKey<compressed extends boolean = false, bigintType = bigint, numberType = number> = Compute<compressed extends true ? {
+    prefix: numberType;
+    x: bigintType;
+    y?: undefined;
+} : {
+    prefix: numberType;
+    x: bigintType;
+    y: bigintType;
+}>;
+/**
+ * Asserts that a {@link ox#PublicKey.PublicKey} is valid.
+ *
+ * @example
+ * ```ts twoslash
+ * import { PublicKey } from 'ox'
+ *
+ * PublicKey.assert({
+ *   prefix: 4,
+ *   y: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+ * })
+ * // @error: PublicKey.InvalidError: Value \`{"y":"1"}\` is not a valid public key.
+ * // @error: Public key must contain:
+ * // @error: - an `x` and `prefix` value (compressed)
+ * // @error: - an `x`, `y`, and `prefix` value (uncompressed)
+ * ```
+ *
+ * @param publicKey - The public key object to assert.
+ */
+export declare function assert(publicKey: ExactPartial<PublicKey>, options?: assert.Options): asserts publicKey is PublicKey;
+export declare namespace assert {
+    type Options = {
+        /** Whether or not the public key should be compressed. */
+        compressed?: boolean;
+    };
+    type ErrorType = InvalidError | InvalidPrefixError | Errors.GlobalErrorType;
+}
+/**
+ * Compresses a {@link ox#PublicKey.PublicKey}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { PublicKey } from 'ox'
+ *
+ * const publicKey = PublicKey.from({
+ *   prefix: 4,
+ *   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+ *   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+ * })
+ *
+ * const compressed = PublicKey.compress(publicKey) // [!code focus]
+ * // @log: {
+ * // @log:   prefix: 3,
+ * // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+ * // @log: }
+ * ```
+ *
+ * @param publicKey - The public key to compress.
+ * @returns The compressed public key.
+ */
+export declare function compress(publicKey: PublicKey<false>): PublicKey<true>;
+export declare namespace compress {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Instantiates a typed {@link ox#PublicKey.PublicKey} object from a {@link ox#PublicKey.PublicKey}, {@link ox#Bytes.Bytes}, or {@link ox#Hex.Hex}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { PublicKey } from 'ox'
+ *
+ * const publicKey = PublicKey.from({
+ *   prefix: 4,
+ *   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+ *   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+ * })
+ * // @log: {
+ * // @log:   prefix: 4,
+ * // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+ * // @log:   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+ * // @log: }
+ * ```
+ *
+ * @example
+ * ### From Serialized
+ *
+ * ```ts twoslash
+ * import { PublicKey } from 'ox'
+ *
+ * const publicKey = PublicKey.from('0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5')
+ * // @log: {
+ * // @log:   prefix: 4,
+ * // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+ * // @log:   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+ * // @log: }
+ * ```
+ *
+ * @param value - The public key value to instantiate.
+ * @returns The instantiated {@link ox#PublicKey.PublicKey}.
+ */
+export declare function from<const publicKey extends CompressedPublicKey | UncompressedPublicKey | Hex.Hex | Bytes.Bytes>(value: from.Value<publicKey>): from.ReturnType<publicKey>;
+/** @internal */
+type CompressedPublicKey = PublicKey<true>;
+/** @internal */
+type UncompressedPublicKey = Omit<PublicKey<false>, 'prefix'> & {
+    prefix?: PublicKey['prefix'] | undefined;
+};
+export declare namespace from {
+    type Value<publicKey extends CompressedPublicKey | UncompressedPublicKey | Hex.Hex | Bytes.Bytes = PublicKey> = publicKey | CompressedPublicKey | UncompressedPublicKey;
+    type ReturnType<publicKey extends CompressedPublicKey | UncompressedPublicKey | Hex.Hex | Bytes.Bytes = PublicKey> = publicKey extends CompressedPublicKey | UncompressedPublicKey ? publicKey extends UncompressedPublicKey ? Compute<publicKey & {
+        readonly prefix: 0x04;
+    }> : publicKey : PublicKey;
+    type ErrorType = assert.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Deserializes a {@link ox#PublicKey.PublicKey} from a {@link ox#Bytes.Bytes} value.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { PublicKey } from 'ox'
+ *
+ * const publicKey = PublicKey.fromBytes(new Uint8Array([128, 3, 131, ...]))
+ * // @log: {
+ * // @log:   prefix: 4,
+ * // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+ * // @log:   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+ * // @log: }
+ * ```
+ *
+ * @param publicKey - The serialized public key.
+ * @returns The deserialized public key.
+ */
+export declare function fromBytes(publicKey: Bytes.Bytes): PublicKey;
+export declare namespace fromBytes {
+    type ErrorType = fromHex.ErrorType | Hex.fromBytes.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Deserializes a {@link ox#PublicKey.PublicKey} from a {@link ox#Hex.Hex} value.
+ *
+ * @example
+ * ```ts twoslash
+ * import { PublicKey } from 'ox'
+ *
+ * const publicKey = PublicKey.fromHex('0x8318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5')
+ * // @log: {
+ * // @log:   prefix: 4,
+ * // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+ * // @log:   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+ * // @log: }
+ * ```
+ *
+ * @example
+ * ### Deserializing a Compressed Public Key
+ *
+ * ```ts twoslash
+ * import { PublicKey } from 'ox'
+ *
+ * const publicKey = PublicKey.fromHex('0x038318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed75')
+ * // @log: {
+ * // @log:   prefix: 3,
+ * // @log:   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+ * // @log: }
+ * ```
+ *
+ * @param publicKey - The serialized public key.
+ * @returns The deserialized public key.
+ */
+export declare function fromHex(publicKey: Hex.Hex): PublicKey;
+export declare namespace fromHex {
+    type ErrorType = Hex.slice.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Serializes a {@link ox#PublicKey.PublicKey} to {@link ox#Bytes.Bytes}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { PublicKey } from 'ox'
+ *
+ * const publicKey = PublicKey.from({
+ *   prefix: 4,
+ *   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+ *   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+ * })
+ *
+ * const bytes = PublicKey.toBytes(publicKey) // [!code focus]
+ * // @log: Uint8Array [128, 3, 131, ...]
+ * ```
+ *
+ * @param publicKey - The public key to serialize.
+ * @returns The serialized public key.
+ */
+export declare function toBytes(publicKey: PublicKey<boolean>, options?: toBytes.Options): Bytes.Bytes;
+export declare namespace toBytes {
+    type Options = {
+        /**
+         * Whether to include the prefix in the serialized public key.
+         * @default true
+         */
+        includePrefix?: boolean | undefined;
+    };
+    type ErrorType = Hex.fromNumber.ErrorType | Bytes.fromHex.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Serializes a {@link ox#PublicKey.PublicKey} to {@link ox#Hex.Hex}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { PublicKey } from 'ox'
+ *
+ * const publicKey = PublicKey.from({
+ *   prefix: 4,
+ *   x: 59295962801117472859457908919941473389380284132224861839820747729565200149877n,
+ *   y: 24099691209996290925259367678540227198235484593389470330605641003500238088869n,
+ * })
+ *
+ * const hex = PublicKey.toHex(publicKey) // [!code focus]
+ * // @log: '0x048318535b54105d4a7aae60c08fc45f9687181b4fdfc625bd1a753fa7397fed753547f11ca8696646f2f3acb08e31016afac23e630c5d11f59f61fef57b0d2aa5'
+ * ```
+ *
+ * @param publicKey - The public key to serialize.
+ * @returns The serialized public key.
+ */
+export declare function toHex(publicKey: PublicKey<boolean>, options?: toHex.Options): Hex.Hex;
+export declare namespace toHex {
+    type Options = {
+        /**
+         * Whether to include the prefix in the serialized public key.
+         * @default true
+         */
+        includePrefix?: boolean | undefined;
+    };
+    type ErrorType = Hex.fromNumber.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Validates a {@link ox#PublicKey.PublicKey}. Returns `true` if valid, `false` otherwise.
+ *
+ * @example
+ * ```ts twoslash
+ * import { PublicKey } from 'ox'
+ *
+ * const valid = PublicKey.validate({
+ *   prefix: 4,
+ *   y: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+ * })
+ * // @log: false
+ * ```
+ *
+ * @param publicKey - The public key object to assert.
+ */
+export declare function validate(publicKey: ExactPartial<PublicKey>, options?: validate.Options): boolean;
+export declare namespace validate {
+    type Options = {
+        /** Whether or not the public key should be compressed. */
+        compressed?: boolean;
+    };
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Thrown when a public key is invalid.
+ *
+ * @example
+ * ```ts twoslash
+ * import { PublicKey } from 'ox'
+ *
+ * PublicKey.assert({ y: 1n })
+ * // @error: PublicKey.InvalidError: Value `{"y":1n}` is not a valid public key.
+ * // @error: Public key must contain:
+ * // @error: - an `x` and `prefix` value (compressed)
+ * // @error: - an `x`, `y`, and `prefix` value (uncompressed)
+ * ```
+ */
+export declare class InvalidError extends Errors.BaseError {
+    readonly name = "PublicKey.InvalidError";
+    constructor({ publicKey }: {
+        publicKey: unknown;
+    });
+}
+/** Thrown when a public key has an invalid prefix. */
+export declare class InvalidPrefixError<cause extends InvalidCompressedPrefixError | InvalidUncompressedPrefixError = InvalidCompressedPrefixError | InvalidUncompressedPrefixError> extends Errors.BaseError<cause> {
+    readonly name = "PublicKey.InvalidPrefixError";
+    constructor({ prefix, cause }: {
+        prefix: number | undefined;
+        cause: cause;
+    });
+}
+/** Thrown when the public key has an invalid prefix for a compressed public key. */
+export declare class InvalidCompressedPrefixError extends Errors.BaseError {
+    readonly name = "PublicKey.InvalidCompressedPrefixError";
+    constructor();
+}
+/** Thrown when the public key has an invalid prefix for an uncompressed public key. */
+export declare class InvalidUncompressedPrefixError extends Errors.BaseError {
+    readonly name = "PublicKey.InvalidUncompressedPrefixError";
+    constructor();
+}
+/** Thrown when the public key has an invalid serialized size. */
+export declare class InvalidSerializedSizeError extends Errors.BaseError {
+    readonly name = "PublicKey.InvalidSerializedSizeError";
+    constructor({ publicKey }: {
+        publicKey: Hex.Hex | Bytes.Bytes;
+    });
+}
+export {};

package/dist/types/node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/Rlp.d.ts

@@ -0,0 +1,135 @@
+import * as Bytes from './Bytes.js';
+import * as Errors from './Errors.js';
+import * as Hex from './Hex.js';
+import * as Cursor from './internal/cursor.js';
+import type { ExactPartial, RecursiveArray } from './internal/types.js';
+/**
+ * Decodes a Recursive-Length Prefix (RLP) value into a {@link ox#Bytes.Bytes} value.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Rlp } from 'ox'
+ * Rlp.toBytes('0x8b68656c6c6f20776f726c64')
+ * // Uint8Array([139, 104, 101, 108, 108, 111,  32, 119, 111, 114, 108, 100])
+ * ```
+ *
+ * @param value - The value to decode.
+ * @returns The decoded {@link ox#Bytes.Bytes} value.
+ */
+export declare function toBytes(value: Bytes.Bytes | Hex.Hex): RecursiveArray<Bytes.Bytes>;
+export declare namespace toBytes {
+    type ErrorType = to.ErrorType;
+}
+/**
+ * Decodes a Recursive-Length Prefix (RLP) value into a {@link ox#Hex.Hex} value.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Rlp } from 'ox'
+ * Rlp.toHex('0x8b68656c6c6f20776f726c64')
+ * // 0x68656c6c6f20776f726c64
+ * ```
+ *
+ * @param value - The value to decode.
+ * @returns The decoded {@link ox#Hex.Hex} value.
+ */
+export declare function toHex(value: Bytes.Bytes | Hex.Hex): RecursiveArray<Hex.Hex>;
+export declare namespace toHex {
+    type ErrorType = to.ErrorType;
+}
+/** @internal */
+export declare function to<value extends Bytes.Bytes | Hex.Hex, to extends 'Hex' | 'Bytes'>(value: value, to: to | 'Hex' | 'Bytes'): to.ReturnType<to>;
+/** @internal */
+export declare namespace to {
+    type ReturnType<to extends 'Hex' | 'Bytes' = 'Hex' | 'Bytes'> = (to extends 'Bytes' ? RecursiveArray<Bytes.Bytes> : never) | (to extends 'Hex' ? RecursiveArray<Hex.Hex> : never);
+    type ErrorType = Bytes.fromHex.ErrorType | decodeRlpCursor.ErrorType | Cursor.create.ErrorType | Hex.InvalidLengthError | Errors.GlobalErrorType;
+}
+/** @internal */
+/** @internal */
+export declare function decodeRlpCursor<to extends 'Hex' | 'Bytes' = 'Hex'>(cursor: Cursor.Cursor, to?: to | 'Hex' | 'Bytes' | undefined): decodeRlpCursor.ReturnType<to>;
+/** @internal */
+export declare namespace decodeRlpCursor {
+    type ReturnType<to extends 'Hex' | 'Bytes' = 'Hex'> = to.ReturnType<to>;
+    type ErrorType = Hex.fromBytes.ErrorType | readLength.ErrorType | readList.ErrorType | Errors.GlobalErrorType;
+}
+/** @internal */
+export declare function readLength(cursor: Cursor.Cursor, prefix: number, offset: number): number;
+/** @internal */
+export declare namespace readLength {
+    type ErrorType = Errors.BaseError | Errors.GlobalErrorType;
+}
+/** @internal */
+export declare function readList<to extends 'Hex' | 'Bytes'>(cursor: Cursor.Cursor, length: number, to: to | 'Hex' | 'Bytes'): decodeRlpCursor.ReturnType<to>[];
+/** @internal */
+export declare namespace readList {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Encodes a {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value into a Recursive-Length Prefix (RLP) value.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes, Rlp } from 'ox'
+ *
+ * Rlp.from('0x68656c6c6f20776f726c64', { as: 'Hex' })
+ * // @log: 0x8b68656c6c6f20776f726c64
+ *
+ * Rlp.from(Bytes.from([139, 104, 101, 108, 108, 111,  32, 119, 111, 114, 108, 100]), { as: 'Bytes' })
+ * // @log: Uint8Array([104, 101, 108, 108, 111,  32, 119, 111, 114, 108, 100])
+ * ```
+ *
+ * @param value - The {@link ox#Bytes.Bytes} or {@link ox#Hex.Hex} value to encode.
+ * @param options - Options.
+ * @returns The RLP value.
+ */
+export declare function from<as extends 'Hex' | 'Bytes'>(value: RecursiveArray<Bytes.Bytes> | RecursiveArray<Hex.Hex>, options: from.Options<as>): from.ReturnType<as>;
+export declare namespace from {
+    type Options<as extends 'Hex' | 'Bytes'> = {
+        /** The type to convert the RLP value to. */
+        as: as | 'Hex' | 'Bytes';
+    };
+    type ReturnType<as extends 'Hex' | 'Bytes'> = (as extends 'Bytes' ? Bytes.Bytes : never) | (as extends 'Hex' ? Hex.Hex : never);
+    type ErrorType = Cursor.create.ErrorType | Hex.fromBytes.ErrorType | Bytes.fromHex.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Encodes a {@link ox#Bytes.Bytes} value into a Recursive-Length Prefix (RLP) value.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Bytes, Rlp } from 'ox'
+ *
+ * Rlp.fromBytes(Bytes.from([139, 104, 101, 108, 108, 111,  32, 119, 111, 114, 108, 100]))
+ * // @log: Uint8Array([104, 101, 108, 108, 111,  32, 119, 111, 114, 108, 100])
+ * ```
+ *
+ * @param bytes - The {@link ox#Bytes.Bytes} value to encode.
+ * @param options - Options.
+ * @returns The RLP value.
+ */
+export declare function fromBytes<as extends 'Hex' | 'Bytes' = 'Bytes'>(bytes: RecursiveArray<Bytes.Bytes>, options?: fromBytes.Options<as>): fromBytes.ReturnType<as>;
+export declare namespace fromBytes {
+    type Options<as extends 'Hex' | 'Bytes' = 'Bytes'> = ExactPartial<from.Options<as>>;
+    type ReturnType<as extends 'Hex' | 'Bytes' = 'Bytes'> = from.ReturnType<as>;
+    type ErrorType = from.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Encodes a {@link ox#Hex.Hex} value into a Recursive-Length Prefix (RLP) value.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Rlp } from 'ox'
+ *
+ * Rlp.fromHex('0x68656c6c6f20776f726c64')
+ * // @log: 0x8b68656c6c6f20776f726c64
+ * ```
+ *
+ * @param hex - The {@link ox#Hex.Hex} value to encode.
+ * @param options - Options.
+ * @returns The RLP value.
+ */
+export declare function fromHex<as extends 'Hex' | 'Bytes' = 'Hex'>(hex: RecursiveArray<Hex.Hex>, options?: fromHex.Options<as>): fromHex.ReturnType<as>;
+export declare namespace fromHex {
+    type Options<as extends 'Hex' | 'Bytes' = 'Hex'> = ExactPartial<from.Options<as>>;
+    type ReturnType<as extends 'Hex' | 'Bytes' = 'Hex'> = from.ReturnType<as>;
+    type ErrorType = from.ErrorType | Errors.GlobalErrorType;
+}