iso-signatures 0.3.2 → 0.4.0

package/dist/src/signers/eip191.d.ts

@@ -0,0 +1,549 @@
+/**
+ * @typedef {import('../types.js').ISigner<string>} ISigner
+ * @typedef {import('ox').Provider.Provider} Provider
+ */
+/**
+ * EIP191 signer
+ *
+ * @implements {ISigner}
+ */
+export class EIP191Signer extends DID implements ISigner {
+    /**
+     * Generate a new signer
+     *
+     * @param {object} options
+     * @param {Provider} options.provider -  https://oxlib.sh/guides/eip-1193#eip-1193-providers
+     * @param {`0x${string}`} [options.address] - default: first account from provider
+     * @param {number | `0x${string}`} [options.chainId] - default: 1
+     * @param {string} [options.namespace] - default: eip155
+     *
+     * @example
+     * ```ts twoslash
+     * import { Provider } from 'ox'
+     * const provider = Provider.from(window.ethereum)
+     * const signer = await EIP191Signer.generate({
+     *   provider,
+     * })
+     * ```
+     */
+    static from(options: {
+        provider: Provider;
+        address?: `0x${string}` | undefined;
+        chainId?: number | `0x${string}` | undefined;
+        namespace?: string | undefined;
+    }): Promise<EIP191Signer>;
+    /**
+     * Create a DIDPkh from an address
+     *
+     * @param {Provider} provider -  https://oxlib.sh/guides/eip-1193#eip-1193-providers
+     * @param {`0x${string}`} address
+     * @param {number | `0x${string}`} [chainId]
+     * @param {string} [namespace]
+     */
+    constructor(provider: Provider, address: `0x${string}`, chainId?: number | `0x${string}`, namespace?: string);
+    /** @type {import('../types.js').SignatureType} */
+    signatureType: import("../types.js").SignatureType;
+    provider: {
+        request: Provider.RequestFn<{
+            Request: {
+                method: "eth_accounts";
+                params?: undefined;
+            };
+            ReturnType: readonly import("ox/Address").Address[];
+        } | {
+            Request: {
+                method: "eth_blobBaseFee";
+                params?: undefined;
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_blockNumber";
+                params?: undefined;
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_call";
+                params: [transaction: import("ox/TransactionRequest").Rpc] | [transaction: import("ox/TransactionRequest").Rpc, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier] | [transaction: import("ox/TransactionRequest").Rpc, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier, stateOverrides: import("ox/StateOverrides").Rpc];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_chainId";
+                params?: undefined;
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_coinbase";
+                params?: undefined;
+            };
+            ReturnType: import("ox/Address").Address;
+        } | {
+            Request: {
+                method: "eth_estimateGas";
+                params: [transaction: import("ox/TransactionRequest").Rpc] | [transaction: import("ox/TransactionRequest").Rpc, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier] | [transaction: import("ox/TransactionRequest").Rpc, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier, stateOverrides: import("ox/StateOverrides").Rpc];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_feeHistory";
+                params: [blockCount: import("ox/Hex").Hex, newestBlock: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag, rewardPercentiles: number[] | undefined];
+            };
+            ReturnType: import("ox/Fee").FeeHistoryRpc;
+        } | {
+            Request: {
+                method: "eth_gasPrice";
+                params?: undefined;
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_getBalance";
+                params: [address: import("ox/Address").Address, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_getBlockByHash";
+                params: [hash: import("ox/Hex").Hex, includeTransactionObjects: boolean];
+            };
+            ReturnType: import("ox/Block").Rpc | null;
+        } | {
+            Request: {
+                method: "eth_getBlockByNumber";
+                params: [block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag, includeTransactionObjects: boolean];
+            };
+            ReturnType: import("ox/Block").Rpc | null;
+        } | {
+            Request: {
+                method: "eth_getBlockTransactionCountByHash";
+                params: [hash: import("ox/Hex").Hex];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_getBlockTransactionCountByNumber";
+                params: [block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_getCode";
+                params: [address: import("ox/Address").Address, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_getFilterChanges";
+                params: [filterId: import("ox/Hex").Hex];
+            };
+            ReturnType: readonly import("ox/Log").Rpc[] | readonly import("ox/Hex").Hex[];
+        } | {
+            Request: {
+                method: "eth_getFilterLogs";
+                params: [filterId: import("ox/Hex").Hex];
+            };
+            ReturnType: readonly import("ox/Log").Rpc[];
+        } | {
+            Request: {
+                method: "eth_getLogs";
+                params: [filter: import("ox/Filter").Rpc];
+            };
+            ReturnType: readonly import("ox/Log").Rpc[];
+        } | {
+            Request: {
+                method: "eth_getProof";
+                params: [address: import("ox/Address").Address, storageKeys: import("ox/Hex").Hex[], block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier];
+            };
+            ReturnType: import("ox/AccountProof").Rpc;
+        } | {
+            Request: {
+                method: "eth_getStorageAt";
+                params: [address: import("ox/Address").Address, index: import("ox/Hex").Hex, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_getTransactionByBlockHashAndIndex";
+                params: [hash: import("ox/Hex").Hex, index: import("ox/Hex").Hex];
+            };
+            ReturnType: import("ox/Transaction").Rpc | null;
+        } | {
+            Request: {
+                method: "eth_getTransactionByBlockNumberAndIndex";
+                params: [block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag, index: import("ox/Hex").Hex];
+            };
+            ReturnType: import("ox/Transaction").Rpc | null;
+        } | {
+            Request: {
+                method: "eth_getTransactionByHash";
+                params: [hash: import("ox/Hex").Hex];
+            };
+            ReturnType: import("ox/Transaction").Rpc | null;
+        } | {
+            Request: {
+                method: "eth_getTransactionCount";
+                params: [address: import("ox/Address").Address, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_getTransactionReceipt";
+                params: [hash: import("ox/Hex").Hex];
+            };
+            ReturnType: import("ox/TransactionReceipt").Rpc | null;
+        } | {
+            Request: {
+                method: "eth_getUncleCountByBlockHash";
+                params: [hash: import("ox/Hex").Hex];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_getUncleCountByBlockNumber";
+                params: [block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_maxPriorityFeePerGas";
+                params?: undefined;
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_newBlockFilter";
+                params?: undefined;
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_newFilter";
+                params: [filter: import("ox/Filter").Rpc];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_newPendingTransactionFilter";
+                params?: undefined;
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_protocolVersion";
+                params?: undefined;
+            };
+            ReturnType: string;
+        } | {
+            Request: {
+                method: "eth_requestAccounts";
+                params?: undefined;
+            };
+            ReturnType: readonly import("ox/Address").Address[];
+        } | {
+            Request: {
+                method: "eth_sendRawTransaction";
+                params: [serializedTransaction: import("ox/Hex").Hex];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_sendTransaction";
+                params: [transaction: import("ox/TransactionRequest").Rpc];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_simulateV1";
+                params: [{
+                    blockStateCalls: readonly {
+                        blockOverrides?: import("ox/BlockOverrides").Rpc | undefined;
+                        calls?: readonly import("ox/TransactionRequest").Rpc[] | undefined;
+                        stateOverrides?: import("ox/StateOverrides").Rpc | undefined;
+                    }[];
+                    returnFullTransactions?: boolean | undefined;
+                    traceTransfers?: boolean | undefined;
+                    validation?: boolean | undefined;
+                }, block: import("ox/Block").Number<import("ox/Hex").Hex> | import("ox/Block").Tag | import("ox/Block").Hash | import("ox/Block").Identifier];
+            };
+            ReturnType: readonly (import("ox/Block").Rpc & {
+                calls?: readonly {
+                    error?: {
+                        data?: import("ox/Hex").Hex | undefined;
+                        code: number;
+                        message: string;
+                    } | undefined;
+                    logs?: readonly import("ox/Log").Rpc[] | undefined;
+                    gasUsed: import("ox/Hex").Hex;
+                    returnData: import("ox/Hex").Hex;
+                    status: import("ox/Hex").Hex;
+                }[] | undefined;
+            })[];
+        } | {
+            Request: {
+                method: "eth_signTransaction";
+                params: [request: import("ox/TransactionRequest").Rpc];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_signTypedData_v4";
+                params: [address: import("ox/Address").Address, message: string];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_uninstallFilter";
+                params: [filterId: import("ox/Hex").Hex];
+            };
+            ReturnType: boolean;
+        } | {
+            Request: {
+                method: "eth_requestAccounts";
+                params?: undefined;
+            };
+            ReturnType: readonly import("ox/Address").Address[];
+        } | {
+            Request: {
+                method: "eth_sendRawTransaction";
+                params: [serializedTransaction: import("ox/Hex").Hex];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_sendTransaction";
+                params: [transaction: import("ox/TransactionRequest").Rpc];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_signTransaction";
+                params: [request: import("ox/TransactionRequest").Rpc];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "eth_signTypedData_v4";
+                params: [address: import("ox/Address").Address, message: string];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "personal_sign";
+                params: [data: import("ox/Hex").Hex, address: import("ox/Address").Address];
+            };
+            ReturnType: import("ox/Hex").Hex;
+        } | {
+            Request: {
+                method: "wallet_addEthereumChain";
+                params: [chain: {
+                    chainId: string;
+                    chainName: string;
+                    nativeCurrency?: {
+                        name: string;
+                        symbol: string;
+                        decimals: number;
+                    } | undefined | undefined;
+                    rpcUrls: readonly string[];
+                    blockExplorerUrls?: readonly string[] | undefined;
+                    iconUrls?: readonly string[] | undefined;
+                }];
+            };
+            ReturnType: null;
+        } | {
+            Request: {
+                method: "wallet_getCallsStatus";
+                params?: [string];
+            };
+            ReturnType: {
+                atomic: boolean;
+                capabilities?: {
+                    [capability: string]: any;
+                } | undefined;
+                chainId: import("ox/Hex").Hex;
+                id: string;
+                receipts?: readonly {
+                    logs: {
+                        address: import("ox/Hex").Hex;
+                        data: import("ox/Hex").Hex;
+                        topics: readonly import("ox/Hex").Hex[];
+                    }[];
+                    status: import("ox/Hex").Hex;
+                    blockHash: import("ox/Hex").Hex;
+                    blockNumber: import("ox/Hex").Hex;
+                    gasUsed: import("ox/Hex").Hex;
+                    transactionHash: import("ox/Hex").Hex;
+                }[] | undefined;
+                status: number;
+                version: string;
+            };
+        } | {
+            Request: {
+                method: "wallet_getCapabilities";
+                params?: readonly [] | readonly [import("ox/Address").Address | undefined] | readonly [import("ox/Address").Address | undefined, readonly import("ox/Hex").Hex[] | undefined] | undefined;
+            };
+            ReturnType: {
+                [x: `0x${string}`]: {
+                    [capability: string]: any;
+                };
+            };
+        } | {
+            Request: {
+                method: "wallet_getPermissions";
+                params?: undefined;
+            };
+            ReturnType: readonly {
+                caveats: readonly {
+                    type: string;
+                    value: any;
+                }[];
+                date: number;
+                id: string;
+                invoker: `http://${string}` | `https://${string}`;
+                parentCapability: "eth_accounts" | string;
+            }[];
+        } | {
+            Request: {
+                method: "wallet_grantPermissions";
+                params?: [{
+                    signer?: {
+                        type: string;
+                        data?: unknown | undefined;
+                    } | undefined;
+                    permissions: readonly {
+                        data: unknown;
+                        policies: readonly {
+                            data: unknown;
+                            type: string;
+                        }[];
+                        required?: boolean | undefined;
+                        type: string;
+                    }[];
+                    expiry: number;
+                }];
+            };
+            ReturnType: {
+                expiry: number;
+                factory?: `0x${string}` | undefined | undefined;
+                factoryData?: string | undefined | undefined;
+                grantedPermissions: readonly {
+                    data: unknown;
+                    policies: readonly {
+                        data: unknown;
+                        type: string;
+                    }[];
+                    required?: boolean | undefined;
+                    type: string;
+                }[];
+                permissionsContext: string;
+                signerData?: {
+                    userOpBuilder?: `0x${string}` | undefined;
+                    submitToAddress?: `0x${string}` | undefined;
+                } | undefined | undefined;
+            };
+        } | {
+            Request: {
+                method: "wallet_requestPermissions";
+                params: [permissions: {
+                    eth_accounts: Record<string, any>;
+                }];
+            };
+            ReturnType: readonly {
+                caveats: readonly {
+                    type: string;
+                    value: any;
+                }[];
+                date: number;
+                id: string;
+                invoker: `http://${string}` | `https://${string}`;
+                parentCapability: "eth_accounts" | string;
+            }[];
+        } | {
+            Request: {
+                method: "wallet_revokePermissions";
+                params: [permissions: {
+                    eth_accounts: Record<string, any>;
+                }];
+            };
+            ReturnType: null;
+        } | {
+            Request: {
+                method: "wallet_sendCalls";
+                params: [{
+                    atomicRequired: boolean;
+                    calls: readonly {
+                        capabilities?: {
+                            [capability: string]: any;
+                        } | undefined;
+                        to?: import("ox/Address").Address | undefined;
+                        data?: import("ox/Hex").Hex | undefined;
+                        value?: import("ox/Hex").Hex | undefined;
+                    }[];
+                    capabilities?: {
+                        [capability: string]: any;
+                    } | undefined;
+                    chainId?: import("ox/Hex").Hex | undefined;
+                    id?: string | undefined;
+                    from?: import("ox/Address").Address | undefined;
+                    version: string;
+                }];
+            };
+            ReturnType: {
+                capabilities?: {
+                    [capability: string]: any;
+                } | undefined;
+                id: string;
+            };
+        } | {
+            Request: {
+                method: "wallet_showCallsStatus";
+                params: [string];
+            };
+            ReturnType: undefined;
+        } | {
+            Request: {
+                method: "wallet_switchEthereumChain";
+                params: [chain: {
+                    chainId: string;
+                }];
+            };
+            ReturnType: null;
+        } | {
+            Request: {
+                method: "wallet_watchAsset";
+                params: [{
+                    type: "ERC20";
+                    options: {
+                        address: string;
+                        symbol: string;
+                        decimals: number;
+                        image?: string | undefined;
+                    };
+                }];
+            };
+            ReturnType: boolean;
+        }>;
+        on: Provider.EventListenerFn;
+        removeListener: Provider.EventListenerFn;
+    };
+    address: `0x${string}`;
+    chainId: number | `0x${string}`;
+    namespace: string;
+    /**
+     * Sign a message
+     *
+     * @param {Uint8Array} message
+     */
+    sign(message: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
+    /**
+     * Export the signer as a encoded string
+     */
+    export(): string;
+}
+export type ISigner = import("../types.js").ISigner<string>;
+export type Provider = import("ox").Provider.Provider;
+import { DID } from 'iso-did';
+import { Provider } from 'ox';
+//# sourceMappingURL=eip191.d.ts.map

package/dist/src/signers/eip191.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eip191.d.ts","sourceRoot":"","sources":["../../../src/signers/eip191.js"],"names":[],"mappings":"AAKA;;;GAGG;AAEH;;;;GAIG;AACH,iDAFgB,OAAO;IAuBrB;;;;;;;;;;;;;;;;;OAiBG;IACH,qBAdG;QAA0B,QAAQ,EAA1B,QAAQ;QACgB,OAAO;QACE,OAAO;QACvB,SAAS;KAElC,yBAwBF;IAlDD;;;;;;;OAOG;IACH,sBALW,QAAQ,WACR,KAAK,MAAM,EAAE,YACb,MAAM,GAAG,KAAK,MAAM,EAAE,cACtB,MAAM,EAShB;IAlBD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IAaX;;;;sBAW4D,CAAC;;;;;;sBAQzD,CAAC;;;;;;sBAS2B,CAAC;;;;;;;;;;;;sBAqCwQ,CAAC;;;;;;sBAAmP,CAAC;;;;;;;;;;;;;;;;;;sBAA6jE,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAAqxP,CAAC;;;;;;sBAAkT,CAAC;;;;;;;;;;;;sBAAovB,CAAC;;;;;;sBAAuQ,CAAC;;;;;;sBAAwW,CAAC;;;;;;;;;;;;;;;;;;;;sCAA+4B,CAAC;6BAA2D,CAAC;sCAAmF,CAAC;;0CAA6F,CAAC;kCAAqD,CAAC;8BAAiD,CAAC;;;;qBAAkM,CAAC;yBAA8B,CAAC;4BAAwB,CAAC;;;;wBAAiI,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;sBApExjb,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoE+gC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;sBAA0Q,CAAC;;;;;;;;;;sBAA+Z,CAAC;;;;;;;;;;;;;;;sBAAmQ,CAAC;;;4BAAguI,CAAC;;;;;;;;gCAA4M,CAAC;;;;;;;;;;;;;;;;4BAA2f,CAAC;;;;;iCAA8H,CAAC;mCAAoD,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oCAA+R,CAAC;;;0BAAgD,CAAC;4BAA+C,CAAC;6BAAwC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAA68B,CAAC;;;;;;;;MAjEn7Q;IACxB,uBAAsB;IACtB,gCAAsB;IACtB,kBAA0B;IAsC5B;;;;OAIG;IACH,cAFW,UAAU,wCAQpB;IAED;;OAEG;IACH,iBAEC;CAKF;sBAxFY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;uBACrC,OAAO,IAAI,EAAE,QAAQ,CAAC,QAAQ;oBANvB,SAAS;yBAEJ,IAAI"}

package/dist/src/signers/es256k.d.ts

@@ -0,0 +1,55 @@
+/**
+ * ES256K signer (secp256k1 and SHA-256)
+ *
+ * @implements {ISigner}
+ */
+export class ES256KSigner extends DID implements ISigner {
+    /**
+     * Multibase code for secp256k1 private key
+     * @see https://github.com/multiformats/multicodec/blob/3bc7f4c20afe28e10d9d539e2a565578de6dd71c/table.csv#L182
+     * @type {number}
+     */
+    static code: number;
+    /**
+     * Generate a new signer
+     *
+     * @param {Uint8Array} [bytes]
+     */
+    static generate(bytes?: Uint8Array): ES256KSigner;
+    /**
+     * Import a signer from a JWK
+     *
+     * @param {import('iso-did/types').ECJWKPrivate} jwk
+     * @param {import('iso-did/types').VerifiableDID} [did] - Optional DID to verify the JWK
+     */
+    static importJwk(jwk: import("iso-did/types").ECJWKPrivate, did?: import("iso-did/types").VerifiableDID): ES256KSigner;
+    /**
+     * Import a signer from a encoded string
+     *
+     * @param {string} encoded
+     * @param {import('iso-did/types').VerifiableDID} [did]
+     */
+    static import(encoded: string, did?: import("iso-did/types").VerifiableDID): ES256KSigner;
+    /**
+     *
+     * @param {import('iso-did/types').VerifiableDID} did
+     * @param {Uint8Array} privateKey
+     */
+    constructor(did: import("iso-did/types").VerifiableDID, privateKey: Uint8Array);
+    /** @type {import('../types.js').SignatureType} */
+    signatureType: import("../types.js").SignatureType;
+    /**
+     * Sign a message
+     *
+     * @param {Uint8Array} message
+     */
+    sign(message: Uint8Array): Promise<import("@noble/secp256k1").Bytes>;
+    /**
+     * Export the signer as a encoded string
+     */
+    export(): string;
+    #private;
+}
+export type ISigner = import("../types.js").ISigner<string>;
+import { DID } from 'iso-did';
+//# sourceMappingURL=es256k.d.ts.map

package/dist/src/signers/es256k.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"es256k.d.ts","sourceRoot":"","sources":["../../../src/signers/es256k.js"],"names":[],"mappings":"AAqBA;;;;GAIG;AACH,iDAFgB,OAAO;IAGrB;;;;OAIG;IACH,aAFU,MAAM,CAEI;IAoBpB;;;;OAIG;IACH,wBAFW,UAAU,gBAUpB;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,YAAY,QACpC,OAAO,eAAe,EAAE,aAAa,gBAU/C;IAED;;;;;OAKG;IACH,uBAHW,MAAM,QACN,OAAO,eAAe,EAAE,aAAa,gBAU/C;IAzDD;;;;OAIG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,cACrC,UAAU,EAOpB;IAhBD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IAgEb;;;;OAIG;IACH,cAFW,UAAU,6CAMpB;IAED;;OAEG;IACH,iBAEC;;CAKF;sBA/GY,OAAO,aAAa,EAAE,OAAO,CAAC,MAAM,CAAC;oBAL9B,SAAS"}

package/dist/src/signers/rsa.d.ts

@@ -3,11 +3,7 @@
  *
  * @implements {ISigner}
  */
-export class RSASigner implements ISigner {
-    /** @type {Extract<import('iso-did/types').SignatureAlgorithm, "RS256">} */
-    static alg: Extract<import('iso-did/types').SignatureAlgorithm, "RS256">;
-    /** @type {Extract<import('iso-did/types').KeyType, "RSA">} */
-    static type: Extract<import('iso-did/types').KeyType, "RSA">;
+export class RSASigner extends DID implements ISigner {
     static code: number;
     /**
      * Generate a new signer
@@ -19,38 +15,33 @@ export class RSASigner implements ISigner {
      * @param {import('iso-did/types').RSAJWKPrivate} jwk
      * @param {import('iso-did/types').VerifiableDID} [did]
      */
-    static importJwk(jwk: import('iso-did/types').RSAJWKPrivate, did?: import("iso-did/types").VerifiableDID | undefined): Promise<RSASigner>;
+    static importJwk(jwk: import("iso-did/types").RSAJWKPrivate, did?: import("iso-did/types").VerifiableDID): Promise<RSASigner>;
     /**
      * Import a signer from a keypair
      *
      * @param {CryptoKeyPair} keypair
      * @param {import('iso-did/types').VerifiableDID} [did]
      */
-    static import(keypair: CryptoKeyPair, did?: import("iso-did/types").VerifiableDID | undefined): Promise<RSASigner>;
+    static import(keypair: CryptoKeyPair, did?: import("iso-did/types").VerifiableDID): Promise<RSASigner>;
     /**
      * @param {import('iso-did/types').VerifiableDID} did
      * @param {CryptoKeyPair} keypair
      */
-    constructor(did: import('iso-did/types').VerifiableDID, keypair: CryptoKeyPair);
-    did: `did:${string}:${string}`;
-    url: import("iso-did/types").DIDURLObject;
-    type: "P-256" | "P-384" | "P-521" | "Ed25519" | "secp256k1" | "RSA";
-    publicKey: Uint8Array;
-    alg: "EdDSA" | "ES256" | "ES384" | "ES512" | "ES256K" | "RS256";
-    document: import("iso-did/types").DIDDocument;
-    didKey: `did:${string}:${string}`;
+    constructor(did: import("iso-did/types").VerifiableDID, keypair: CryptoKeyPair);
+    /** @type {import('../types.js').SignatureType} */
+    signatureType: import("../types.js").SignatureType;
     /**
      * Sign a message
      *
      * @param {Uint8Array} message
      */
-    sign(message: Uint8Array): Promise<Uint8Array>;
+    sign(message: Uint8Array): Promise<Uint8Array<ArrayBufferLike>>;
     /**
      * Export the signer as a crypto key pair
      */
     export(): CryptoKeyPair;
-    toString(): string;
     #private;
 }
-export type ISigner = import('../types.js').ISigner<CryptoKeyPair>;
+export type ISigner = import("../types.js").ISigner<CryptoKeyPair>;
+import { DID } from 'iso-did';
 //# sourceMappingURL=rsa.d.ts.map

package/dist/src/signers/rsa.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rsa.d.ts","sourceRoot":"","sources":["../../../src/signers/rsa.js"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH;IACE,2EAA2E;IAC3E,YADW,QAAQ,OAAO,eAAe,EAAE,kBAAkB,EAAE,OAAO,CAAC,CACnD;IAEpB,8DAA8D;IAC9D,aADW,QAAQ,OAAO,eAAe,EAAE,OAAO,EAAE,KAAK,CAAC,CACvC;IAGnB,oBAAoB;IAqBpB;;OAEG;IACH,sCAqBC;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,aAAa,+EAgC/C;IAED;;;;;OAKG;IACH,uBAHW,aAAa,+EAevB;IAjGD;;;OAGG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,WACrC,aAAa,EAYvB;IARC,+BAAkB;IAClB,0CAAkB;IAClB,oEAAoB;IACpB,sBAA8B;IAC9B,gEAAkB;IAClB,8CAA4B;IAE5B,kCAAwB;IAsF1B;;;;OAIG;IACH,cAFW,UAAU,uBAUpB;IAED;;OAEG;IACH,wBAEC;IAED,mBAEC;;CACF;sBA9JY,OAAO,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC"}
+{"version":3,"file":"rsa.d.ts","sourceRoot":"","sources":["../../../src/signers/rsa.js"],"names":[],"mappings":"AAsBA;;;;GAIG;AACH,8CAFgB,OAAO;IAIrB,oBAAoB;IAmBpB;;OAEG;IACH,sCAqBC;IAED;;;;;OAKG;IACH,sBAHW,OAAO,eAAe,EAAE,aAAa,QACrC,OAAO,eAAe,EAAE,aAAa,sBA+B/C;IAED;;;;;OAKG;IACH,uBAHW,aAAa,QACb,OAAO,eAAe,EAAE,aAAa,sBAc/C;IA5FD;;;OAGG;IACH,iBAHW,OAAO,eAAe,EAAE,aAAa,WACrC,aAAa,EAOvB;IAZD,kDAAkD;IAClD,eADW,OAAO,aAAa,EAAE,aAAa,CACjC;IAgGb;;;;OAIG;IACH,cAFW,UAAU,wCAUpB;IAED;;OAEG;IACH,wBAEC;;CAKF;sBAnJY,OAAO,aAAa,EAAE,OAAO,CAAC,aAAa,CAAC;oBANrC,SAAS"}