ox 0.0.1 → 0.1.0

package/_types/P256.d.ts

@@ -0,0 +1,207 @@
+import * as Bytes from './Bytes.js';
+import type * as Errors from './Errors.js';
+import * as Hex from './Hex.js';
+import * as PublicKey from './PublicKey.js';
+import type * as Signature from './Signature.js';
+/** Re-export of noble/curves P256 utilities. */
+export declare const noble: Readonly<{
+    create: (hash: import("@noble/curves/abstract/utils.js").CHash) => import("@noble/curves/abstract/weierstrass.js").CurveFn;
+    CURVE: ReturnType<(curve: import("@noble/curves/abstract/weierstrass.js").CurveType) => Readonly<{
+        readonly nBitLength: number;
+        readonly nByteLength: number;
+        readonly Fp: import("@noble/curves/abstract/modular.js").IField<bigint>;
+        readonly n: bigint;
+        readonly h: bigint;
+        readonly hEff?: bigint;
+        readonly Gx: bigint;
+        readonly Gy: bigint;
+        readonly allowInfinityPoint?: boolean;
+        readonly a: bigint;
+        readonly b: bigint;
+        readonly allowedPrivateKeyLengths?: readonly number[];
+        readonly wrapPrivateKey?: boolean;
+        readonly endo?: {
+            beta: bigint;
+            splitScalar: (k: bigint) => {
+                k1neg: boolean;
+                k1: bigint;
+                k2neg: boolean;
+                k2: bigint;
+            };
+        };
+        readonly isTorsionFree?: ((c: import("@noble/curves/abstract/weierstrass.js").ProjConstructor<bigint>, point: import("@noble/curves/abstract/weierstrass.js").ProjPointType<bigint>) => boolean) | undefined;
+        readonly clearCofactor?: ((c: import("@noble/curves/abstract/weierstrass.js").ProjConstructor<bigint>, point: import("@noble/curves/abstract/weierstrass.js").ProjPointType<bigint>) => import("@noble/curves/abstract/weierstrass.js").ProjPointType<bigint>) | undefined;
+        readonly hash: import("@noble/curves/abstract/utils.js").CHash;
+        readonly hmac: (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array;
+        readonly randomBytes: (bytesLength?: number) => Uint8Array;
+        lowS: boolean;
+        readonly bits2int?: (bytes: Uint8Array) => bigint;
+        readonly bits2int_modN?: (bytes: Uint8Array) => bigint;
+        readonly p: bigint;
+    }>>;
+    getPublicKey: (privateKey: import("@noble/curves/abstract/utils.js").PrivKey, isCompressed?: boolean) => Uint8Array;
+    getSharedSecret: (privateA: import("@noble/curves/abstract/utils.js").PrivKey, publicB: import("@noble/curves/abstract/utils.js").Hex, isCompressed?: boolean) => Uint8Array;
+    sign: (msgHash: import("@noble/curves/abstract/utils.js").Hex, privKey: import("@noble/curves/abstract/utils.js").PrivKey, opts?: import("@noble/curves/abstract/weierstrass.js").SignOpts) => import("@noble/curves/abstract/weierstrass.js").RecoveredSignatureType;
+    verify: (signature: import("@noble/curves/abstract/utils.js").Hex | {
+        r: bigint;
+        s: bigint;
+    }, msgHash: import("@noble/curves/abstract/utils.js").Hex, publicKey: import("@noble/curves/abstract/utils.js").Hex, opts?: import("@noble/curves/abstract/weierstrass.js").VerOpts) => boolean;
+    ProjectivePoint: import("@noble/curves/abstract/weierstrass.js").ProjConstructor<bigint>;
+    Signature: import("@noble/curves/abstract/weierstrass.js").SignatureConstructor;
+    utils: {
+        normPrivateKeyToScalar: (key: import("@noble/curves/abstract/utils.js").PrivKey) => bigint;
+        isValidPrivateKey(privateKey: import("@noble/curves/abstract/utils.js").PrivKey): boolean;
+        randomPrivateKey: () => Uint8Array;
+        precompute: (windowSize?: number, point?: import("@noble/curves/abstract/weierstrass.js").ProjPointType<bigint>) => import("@noble/curves/abstract/weierstrass.js").ProjPointType<bigint>;
+    };
+}>;
+/**
+ * Computes the P256 ECDSA public key from a provided private key.
+ *
+ * @example
+ * ```ts twoslash
+ * import { P256 } from 'ox'
+ *
+ * const publicKey = P256.getPublicKey({ privateKey: '0x...' })
+ * ```
+ *
+ * @param options - The options to compute the public key.
+ * @returns The computed public key.
+ */
+export declare function getPublicKey(options: getPublicKey.Options): PublicKey.PublicKey;
+export declare namespace getPublicKey {
+    type Options = {
+        /**
+         * Private key to compute the public key from.
+         */
+        privateKey: Hex.Hex | Bytes.Bytes;
+    };
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Generates a random P256 ECDSA private key.
+ *
+ * @example
+ * ```ts twoslash
+ * import { P256 } from 'ox'
+ *
+ * const privateKey = P256.randomPrivateKey()
+ * ```
+ *
+ * @param options - The options to generate the private key.
+ * @returns The generated private key.
+ */
+export declare function randomPrivateKey<as extends 'Hex' | 'Bytes' = 'Hex'>(options?: randomPrivateKey.Options<as>): randomPrivateKey.ReturnType<as>;
+export declare namespace randomPrivateKey {
+    type Options<as extends 'Hex' | 'Bytes' = 'Hex'> = {
+        /**
+         * Format of the returned private key.
+         * @default 'Hex'
+         */
+        as?: as | 'Hex' | 'Bytes' | undefined;
+    };
+    type ReturnType<as extends 'Hex' | 'Bytes'> = (as extends 'Bytes' ? Bytes.Bytes : never) | (as extends 'Hex' ? Hex.Hex : never);
+    type ErrorType = Hex.fromBytes.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Recovers the signing public key from the signed payload and signature.
+ *
+ * @example
+ * ```ts twoslash
+ * import { P256 } from 'ox'
+ *
+ * const signature = P256.sign({ payload: '0xdeadbeef', privateKey: '0x...' })
+ *
+ * const publicKey = P256.recoverPublicKey({ // [!code focus]
+ *   payload: '0xdeadbeef', // [!code focus]
+ *   signature, // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * @param options - The recovery options.
+ * @returns The recovered public key.
+ */
+export declare function recoverPublicKey(options: recoverPublicKey.Options): PublicKey.PublicKey;
+export declare namespace recoverPublicKey {
+    var parseError: (error: unknown) => recoverPublicKey.ErrorType;
+}
+export declare namespace recoverPublicKey {
+    type Options = {
+        /** Payload that was signed. */
+        payload: Hex.Hex | Bytes.Bytes;
+        /** Signature of the payload. */
+        signature: Signature.Signature;
+    };
+    type ErrorType = PublicKey.from.ErrorType | Hex.fromBytes.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Signs the payload with the provided private key and returns a P256 signature.
+ *
+ * @example
+ * ```ts twoslash
+ * import { P256 } from 'ox'
+ *
+ * const signature = P256.sign({ // [!code focus]
+ *   payload: '0xdeadbeef', // [!code focus]
+ *   privateKey: '0x...' // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * @param options - The signing options.
+ * @returns The ECDSA {@link ox#Signature.Signature}.
+ */
+export declare function sign(options: sign.Options): Signature.Signature;
+export declare namespace sign {
+    var parseError: (error: unknown) => sign.ErrorType;
+}
+export declare namespace sign {
+    type Options = {
+        /** If set to `true`, the payload will be hashed (sha256) before being signed. */
+        hash?: boolean | undefined;
+        /** Payload to sign. */
+        payload: Hex.Hex | Bytes.Bytes;
+        /** ECDSA private key. */
+        privateKey: Hex.Hex | Bytes.Bytes;
+    };
+    type ErrorType = Bytes.fromHex.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Verifies a payload was signed by the provided public key.
+ *
+ * @example
+ *
+ * ```ts twoslash
+ * import { P256 } from 'ox'
+ *
+ * const privateKey = P256.randomPrivateKey()
+ * const publicKey = P256.getPublicKey({ privateKey })
+ * const signature = P256.sign({ payload: '0xdeadbeef', privateKey })
+ *
+ * const verified = P256.verify({ // [!code focus]
+ *   publicKey, // [!code focus]
+ *   payload: '0xdeadbeef', // [!code focus]
+ *   signature, // [!code focus]
+ * }) // [!code focus]
+ * ```
+ *
+ * @param options - The verification options.
+ * @returns Whether the payload was signed by the provided public key.
+ */
+export declare function verify(options: verify.Options): boolean;
+export declare namespace verify {
+    var parseError: (error: unknown) => verify.ErrorType;
+}
+export declare namespace verify {
+    type Options = {
+        /** If set to `true`, the payload will be hashed (sha256) before being verified. */
+        hash?: boolean | undefined;
+        /** Payload that was signed. */
+        payload: Hex.Hex | Bytes.Bytes;
+        /** Public key that signed the payload. */
+        publicKey: PublicKey.PublicKey<boolean>;
+        /** Signature of the payload. */
+        signature: Signature.Signature<boolean>;
+    };
+    type ErrorType = Errors.GlobalErrorType;
+}
+//# sourceMappingURL=P256.d.ts.map

package/_types/P256.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"P256.d.ts","sourceRoot":"","sources":["../P256.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,YAAY,CAAA;AACnC,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,GAAG,MAAM,UAAU,CAAA;AAC/B,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,KAAK,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAEhD,gDAAgD;AAChD,eAAO,MAAM,KAAK;0BA6GP,iCAAqB,mBACzB,uCACQ;qCACY,uCACR;;;4BAMG,mCACP;;;qBAKV,CAAC;;;mCAG4D,CAAC;;;yCAMtC,CAAC;+BACE,CAAC;qBACb,CAAC;;;;;;;;;8BAQO,CAAC,cAAc,uCACrB,yCACJ,uCAA2B;8BACU,CAAC,cAAc,uCACpD,yCAEhB,uCAGC,mCAIK,uCACL;8BACkD,iCAAoB;yCAEpE,GAAI;0CAEkB,CAAC;;yBAIA,CAAC;8BAI7B,CAAC;;;sCAGyC,iCACxC,uBAGK,CAAC;uCAGe,iCAAqB,2BACnB,iCAAqB,mBACpC,CAAC;2BAAqD,iCAEpD,uBAAuB,iCAC9B,eAAe,CAAC,SAAS,uCACN,sBACvB,uCAA2B;+BAIR,iCAAoB;;;uBAC0B,iCAEvD,yBAAyB,iCAAqB,WAC/C,CAAA,SAAS,uCAA2B;4BAElC,uCACY;sBACpB,uCAA0B;;6CAKvB,iCAAoB;6CAEc,iCAAqB;;+BAG1D,CAAA,eAAe,CAAC,SAAS,uCACR,mCACZ,uCAA2B;;EApNN,CAAA;AAE9B;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,YAAY,CAAC,OAAO,GAC5B,SAAS,CAAC,SAAS,CAQrB;AAED,MAAM,CAAC,OAAO,WAAW,YAAY,CAAC;IACpC,KAAK,OAAO,GAAG;QACb;;WAEG;QACH,UAAU,EAAE,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,KAAK,CAAA;KAClC,CAAA;IAED,KAAK,SAAS,GAAG,MAAM,CAAC,eAAe,CAAA;CACxC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,SAAS,KAAK,GAAG,OAAO,GAAG,KAAK,EACjE,OAAO,GAAE,gBAAgB,CAAC,OAAO,CAAC,EAAE,CAAM,GACzC,gBAAgB,CAAC,UAAU,CAAC,EAAE,CAAC,CAKjC;AAED,MAAM,CAAC,OAAO,WAAW,gBAAgB,CAAC;IACxC,KAAK,OAAO,CAAC,EAAE,SAAS,KAAK,GAAG,OAAO,GAAG,KAAK,IAAI;QACjD;;;WAGG;QACH,EAAE,CAAC,EAAE,EAAE,GAAG,KAAK,GAAG,OAAO,GAAG,SAAS,CAAA;KACtC,CAAA;IAED,KAAK,UAAU,CAAC,EAAE,SAAS,KAAK,GAAG,OAAO,IACtC,CAAC,EAAE,SAAS,OAAO,GAAG,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,GAC1C,CAAC,EAAE,SAAS,KAAK,GAAG,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,CAAA;IAExC,KAAK,SAAS,GAAG,GAAG,CAAC,SAAS,CAAC,SAAS,GAAG,MAAM,CAAC,eAAe,CAAA;CAClE;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,gBAAgB,CAAC,OAAO,GAChC,SAAS,CAAC,SAAS,CAWrB;yBAbe,gBAAgB;4BA6BM,OAAO,KAElC,gBAAgB,CAAC,SAAS;;AAhBrC,MAAM,CAAC,OAAO,WAAW,gBAAgB,CAAC;IACxC,KAAK,OAAO,GAAG;QACb,+BAA+B;QAC/B,OAAO,EAAE,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,KAAK,CAAA;QAC9B,gCAAgC;QAChC,SAAS,EAAE,SAAS,CAAC,SAAS,CAAA;KAC/B,CAAA;IAED,KAAK,SAAS,GACV,SAAS,CAAC,IAAI,CAAC,SAAS,GACxB,GAAG,CAAC,SAAS,CAAC,SAAS,GACvB,MAAM,CAAC,eAAe,CAAA;CAC3B;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,GAAG,SAAS,CAAC,SAAS,CAY/D;yBAZe,IAAI;4BA4BM,OAAO,KAAc,IAAI,CAAC,SAAS;;AAd7D,MAAM,CAAC,OAAO,WAAW,IAAI,CAAC;IAC5B,KAAK,OAAO,GAAG;QACb,iFAAiF;QACjF,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;QAC1B,uBAAuB;QACvB,OAAO,EAAE,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,KAAK,CAAA;QAC9B,yBAAyB;QACzB,UAAU,EAAE,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,KAAK,CAAA;KAClC,CAAA;IAED,KAAK,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,GAAG,MAAM,CAAC,eAAe,CAAA;CAClE;AAKD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,GAAG,OAAO,CAQvD;yBARe,MAAM;4BA0BM,OAAO,KAAc,MAAM,CAAC,SAAS;;AAhBjE,MAAM,CAAC,OAAO,WAAW,MAAM,CAAC;IAC9B,KAAK,OAAO,GAAG;QACb,mFAAmF;QACnF,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;QAC1B,+BAA+B;QAC/B,OAAO,EAAE,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,KAAK,CAAA;QAC9B,0CAA0C;QAC1C,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;QACvC,gCAAgC;QAChC,SAAS,EAAE,SAAS,CAAC,SAAS,CAAC,OAAO,CAAC,CAAA;KACxC,CAAA;IAED,KAAK,SAAS,GAAG,MAAM,CAAC,eAAe,CAAA;CACxC"}

package/_types/PersonalMessage.d.ts

@@ -0,0 +1,49 @@
+import type * as Bytes from './Bytes.js';
+import type * as Errors from './Errors.js';
+import * as Hash from './Hash.js';
+import * as Hex from './Hex.js';
+/**
+ * Encodes a personal sign message in [ERC-191 format](https://eips.ethereum.org/EIPS/eip-191#version-0x45-e): `0x19 ‖ "Ethereum Signed Message:\n" + message.length ‖ message`.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Hex, PersonalMessage } from 'ox'
+ *
+ * const data = PersonalMessage.encode(Hex.fromString('hello world'))
+ * // @log: '0x19457468657265756d205369676e6564204d6573736167653a0a313168656c6c6f20776f726c64'
+ * // @log: (0x19 ‖ 'Ethereum Signed Message:\n11' ‖ 'hello world')
+ * ```
+ *
+ * @param data - The data to encode.
+ * @returns The encoded personal sign message.
+ */
+export declare function encode(data: Hex.Hex | Bytes.Bytes): Hex.Hex;
+export declare namespace encode {
+    var parseError: (error: unknown) => encode.ErrorType;
+}
+export declare namespace encode {
+    type ErrorType = Hex.concat.ErrorType | Hex.from.ErrorType | Hex.fromString.ErrorType | Errors.GlobalErrorType;
+}
+/**
+ * Gets the payload to use for signing an [ERC-191 formatted](https://eips.ethereum.org/EIPS/eip-191#version-0x45-e) personal message.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Hex, PersonalMessage, Secp256k1 } from 'ox'
+ *
+ * const payload = PersonalMessage.getSignPayload(Hex.fromString('hello world')) // [!code focus]
+ *
+ * const signature = Secp256k1.sign({ payload, privateKey: '0x...' })
+ * ```
+ *
+ * @param data - The data to get the sign payload for.
+ * @returns The payload to use for signing.
+ */
+export declare function getSignPayload(data: Hex.Hex | Bytes.Bytes): Hex.Hex;
+export declare namespace getSignPayload {
+    var parseError: (error: unknown) => getSignPayload.ErrorType;
+}
+export declare namespace getSignPayload {
+    type ErrorType = Hash.keccak256.ErrorType | encode.ErrorType | Errors.GlobalErrorType;
+}
+//# sourceMappingURL=PersonalMessage.d.ts.map

package/_types/PersonalMessage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PersonalMessage.d.ts","sourceRoot":"","sources":["../PersonalMessage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,KAAK,MAAM,YAAY,CAAA;AACxC,OAAO,KAAK,KAAK,MAAM,MAAM,aAAa,CAAA;AAC1C,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,GAAG,MAAM,UAAU,CAAA;AAE/B;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,CAQ3D;yBARe,MAAM;4BAmBM,OAAO,KAAc,MAAM,CAAC,SAAS;;AATjE,MAAM,CAAC,OAAO,WAAW,MAAM,CAAC;IAC9B,KAAK,SAAS,GACV,GAAG,CAAC,MAAM,CAAC,SAAS,GACpB,GAAG,CAAC,IAAI,CAAC,SAAS,GAClB,GAAG,CAAC,UAAU,CAAC,SAAS,GACxB,MAAM,CAAC,eAAe,CAAA;CAC3B;AAKD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,GAAG,GAAG,KAAK,CAAC,KAAK,GAAG,GAAG,CAAC,GAAG,CAEnE;yBAFe,cAAc;4BAYM,OAAO,KAChC,cAAc,CAAC,SAAS;;AATnC,MAAM,CAAC,OAAO,WAAW,cAAc,CAAC;IACtC,KAAK,SAAS,GACV,IAAI,CAAC,SAAS,CAAC,SAAS,GACxB,MAAM,CAAC,SAAS,GAChB,MAAM,CAAC,eAAe,CAAA;CAC3B"}

package/_types/Provider.d.ts

@@ -0,0 +1,268 @@
+import { EventEmitter } from 'eventemitter3';
+import type * as Address from './Address.js';
+import * as Errors from './Errors.js';
+import type * as RpcSchema from './RpcSchema.js';
+import type * as RpcSchema_internal from './internal/rpcSchema.js';
+import type { Compute } from './internal/types.js';
+/** Options for a {@link ox#Provider.Provider}. */
+export type Options = {
+    /**
+     * Whether to include event functions (`on`, `removeListener`) on the Provider.
+     *
+     * @default true
+     */
+    includeEvents?: boolean | undefined;
+    /**
+     * RPC Schema to use for the Provider's `request` function.
+     * See {@link ox#RpcSchema.(from:function)} for more.
+     *
+     * @default `RpcSchema.Generic`
+     */
+    schema?: RpcSchema.Generic | undefined;
+};
+/** Root type for an EIP-1193 Provider. */
+export type Provider<options extends Options | undefined = undefined, _schema extends RpcSchema.Generic = options extends {
+    schema: infer schema extends RpcSchema.Generic;
+} ? schema : RpcSchema.Default> = Compute<{
+    request: RequestFn<_schema>;
+} & (options extends {
+    includeEvents: true;
+} | undefined ? {
+    on: EventListenerFn;
+    removeListener: EventListenerFn;
+} : {})>;
+/** Type for an EIP-1193 Provider's event emitter. */
+export type Emitter = Compute<EventEmitter<EventMap>>;
+/** EIP-1193 Provider's `request` function. */
+export type RequestFn<schema extends RpcSchema.Generic = RpcSchema.Generic> = <methodName extends RpcSchema.MethodNameGeneric>(parameters: RpcSchema_internal.ExtractRequestOpaque<schema, methodName>) => Promise<RpcSchema.ExtractReturnType<schema, methodName>>;
+/** Type for an EIP-1193 Provider's event listener functions (`on`, `removeListener`, etc). */
+export type EventListenerFn = <event extends keyof EventMap>(event: event, listener: EventMap[event]) => void;
+export type ConnectInfo = {
+    chainId: string;
+};
+export type Message = {
+    type: string;
+    data: unknown;
+};
+export declare class ProviderRpcError extends Error {
+    readonly name = "ProviderRpcError";
+    code: number;
+    details: string;
+    constructor(code: number, message: string);
+}
+export type EventMap = {
+    accountsChanged: (accounts: Address.Address[]) => void;
+    chainChanged: (chainId: string) => void;
+    connect: (connectInfo: ConnectInfo) => void;
+    disconnect: (error: ProviderRpcError) => void;
+    message: (message: Message) => void;
+};
+/**
+ * Creates an EIP-1193 flavored event emitter to be injected onto a Provider.
+ *
+ * @example
+ * ```ts twoslash
+ * import { Provider, RpcRequest, RpcResponse } from 'ox' // [!code focus]
+ *
+ * // 1. Instantiate a Provider Emitter. // [!code focus]
+ * const emitter = Provider.createEmitter() // [!code focus]
+ *
+ * const store = RpcRequest.createStore()
+ *
+ * const provider = Provider.from({
+ *   // 2. Pass the Emitter to the Provider. // [!code focus]
+ *   ...emitter, // [!code focus]
+ *   async request(args) {
+ *     return await fetch('https://1.rpc.thirdweb.com', {
+ *       body: JSON.stringify(store.prepare(args)),
+ *       method: 'POST',
+ *       headers: {
+ *         'Content-Type': 'application/json',
+ *       },
+ *     })
+ *       .then((res) => res.json())
+ *       .then(RpcResponse.parse)
+ *   },
+ * })
+ *
+ * // 3. Emit Provider Events. // [!code focus]
+ * emitter.emit('accountsChanged', ['0x...']) // [!code focus]
+ * ```
+ *
+ * @returns An event emitter.
+ */
+export declare function createEmitter(): Emitter;
+export declare namespace createEmitter {
+    var parseError: (error: unknown) => createEmitter.ErrorType;
+}
+export declare namespace createEmitter {
+    type ErrorType = Errors.GlobalErrorType;
+}
+/**
+ * Instantiates an [EIP-1193](https://eips.ethereum.org/EIPS/eip-1193) {@link ox#Provider.Provider}
+ * from an arbitrary [EIP-1193 Provider](https://eips.ethereum.org/EIPS/eip-1193) interface.
+ *
+ * @example
+ * ### Instantiating with RPC Transport
+ *
+ * Ox's {@link ox#RpcTransport} is EIP-1193 compliant, and can be used to instantiate an EIP-1193 Provider. This means you can use any HTTP RPC endpoint as an EIP-1193 Provider.
+ *
+ * ```ts twoslash
+ * import { Provider, RpcTransport } from 'ox'
+ *
+ * const transport = RpcTransport.fromHttp('https://1.rpc.thirdweb.com')
+ * const provider = Provider.from(transport)
+ * ```
+ *
+ * @example
+ * ### Instantiating with External Providers
+ *
+ * The example below demonstrates how we can instantiate a typed EIP-1193 Provider from an
+ * external EIP-1193 Provider like `window.ethereum`.
+ *
+ * ```ts twoslash
+ * import 'ox/window'
+ * import { Provider } from 'ox'
+ *
+ * const provider = Provider.from(window.ethereum)
+ *
+ * const blockNumber = await provider.request({ method: 'eth_blockNumber' })
+ * ```
+ *
+ * :::tip
+ *
+ * There are also libraries that distribute EIP-1193 Provider objects that you can use with `Provider.from`:
+ *
+ * - [`@walletconnect/ethereum-provider`](https://www.npmjs.com/package/\@walletconnect/ethereum-provider)
+ *
+ * - [`@coinbase/wallet-sdk`](https://www.npmjs.com/package/\@coinbase/wallet-sdk)
+ *
+ * - [`@metamask/detect-provider`](https://www.npmjs.com/package/\@metamask/detect-provider)
+ *
+ * - [`@safe-global/safe-apps-provider`](https://github.com/safe-global/safe-apps-sdk/tree/main/packages/safe-apps-provider)
+ *
+ * - [`mipd`](https://github.com/wevm/mipd): EIP-6963 Multi Injected Providers
+ *
+ * :::
+ *
+ * @example
+ * ### Instantiating a Custom Provider
+ *
+ * The example below demonstrates how we can instantiate a typed EIP-1193 Provider from a
+ * HTTP `fetch` JSON-RPC request. You can use this pattern to integrate with any asynchronous JSON-RPC
+ * transport, including WebSockets and IPC.
+ *
+ * ```ts twoslash
+ * import { Provider, RpcRequest, RpcResponse } from 'ox'
+ *
+ * const store = RpcRequest.createStore()
+ *
+ * const provider = Provider.from({
+ *   async request(args) {
+ *     return await fetch('https://1.rpc.thirdweb.com', {
+ *       body: JSON.stringify(store.prepare(args)),
+ *       method: 'POST',
+ *       headers: {
+ *         'Content-Type': 'application/json',
+ *       },
+ *     })
+ *       .then((res) => res.json())
+ *       .then(RpcResponse.parse)
+ *   },
+ * })
+ *
+ * const blockNumber = await provider.request({ method: 'eth_blockNumber' })
+ * ```
+ *
+ * @example
+ * ### Type-safe Custom Schemas
+ *
+ * It is possible to define your own type-safe schema by using the {@link ox#RpcSchema.(from:function)} type.
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import 'ox/window'
+ * import { Provider, RpcSchema } from 'ox'
+ *
+ * const schema = RpcSchema.from<
+ *   | RpcSchema.Default
+ *   | {
+ *       Request: {
+ *         method: 'abe_foo',
+ *         params: [id: number],
+ *       }
+ *       ReturnType: string
+ *     }
+ *   | {
+ *       Request: {
+ *         method: 'abe_bar',
+ *         params: [id: string],
+ *       }
+ *       ReturnType: string
+ *     }
+ * >()
+ *
+ * const provider = Provider.from(window.ethereum, { schema })
+ *
+ * const blockNumber = await provider.request({ method: 'e' })
+ * //                                                    ^|
+ *
+ *
+ *
+ *
+ *
+ * ```
+ *
+ * @example
+ * ### Instantiating a Provider with Events
+ *
+ * The example below demonstrates how to instantiate a Provider with your own EIP-1193 flavored event emitter.
+ *
+ * This example is useful for Wallets that distribute an EIP-1193 Provider (e.g. webpage injection via `window.ethereum`).
+ *
+ * ```ts twoslash
+ * import { Provider, RpcRequest, RpcResponse } from 'ox'
+ *
+ * // 1. Instantiate a Provider Emitter.
+ * const emitter = Provider.createEmitter() // [!code ++]
+ *
+ * const store = RpcRequest.createStore()
+ *
+ * const provider = Provider.from({
+ *   // 2. Pass the Emitter to the Provider.
+ *   ...emitter, // [!code ++]
+ *   async request(args) {
+ *     return await fetch('https://1.rpc.thirdweb.com', {
+ *       body: JSON.stringify(store.prepare(args)),
+ *       method: 'POST',
+ *       headers: {
+ *         'Content-Type': 'application/json',
+ *       },
+ *     })
+ *       .then((res) => res.json())
+ *       .then(RpcResponse.parse)
+ *   },
+ * })
+ *
+ * // 3. Emit Provider Events.
+ * emitter.emit('accountsChanged', ['0x...']) // [!code ++]
+ * ```
+ *
+ * @param provider - The EIP-1193 provider to convert.
+ * @returns An typed EIP-1193 Provider.
+ */
+export declare function from<const provider extends Provider | unknown, options extends Options | undefined = undefined>(provider: provider | Provider<{
+    schema: RpcSchema.Generic;
+}>, options?: options | Options): Provider<options>;
+export declare namespace from {
+    var parseError: (error: unknown) => from.ErrorType;
+}
+export declare namespace from {
+    type ErrorType = IsUndefinedError | Errors.GlobalErrorType;
+}
+/** Thrown when the provider is undefined. */
+export declare class IsUndefinedError extends Errors.BaseError {
+    readonly name = "Provider.IsUndefinedError";
+    constructor();
+}
+//# sourceMappingURL=Provider.d.ts.map

package/_types/Provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Provider.d.ts","sourceRoot":"","sources":["../Provider.ts"],"names":[],"mappings":"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"}