viem 2.7.5 → 2.7.6

package/_cjs/errors/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
-exports.version = '2.7.5';
+exports.version = '2.7.6';
 //# sourceMappingURL=version.js.map

package/_esm/errors/version.js

@@ -1,2 +1,2 @@
-export const version = '2.7.5';
+export const version = '2.7.6';
 //# sourceMappingURL=version.js.map

package/_types/_test/generated.d.ts

@@ -0,0 +1,428 @@
+export declare const ierc1271WalletABI: readonly [{
+    readonly stateMutability: "view";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "hash";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "signature";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }];
+    readonly name: "isValidSignature";
+    readonly outputs: readonly [{
+        readonly name: "magicValue";
+        readonly internalType: "bytes4";
+        readonly type: "bytes4";
+    }];
+}];
+export declare const verifySigABI: readonly [{
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "_signer";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "_hash";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "_signature";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }];
+}, {
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_signer";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "_hash";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "_signature";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }];
+    readonly name: "isValidUniversalSig";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+}];
+export declare const erc20InvalidTransferEventABI: readonly [{
+    readonly type: "event";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "from";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "to";
+        readonly internalType: "address";
+        readonly type: "address";
+        readonly indexed: false;
+    }, {
+        readonly name: "value";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+    readonly name: "Transfer";
+}, {
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "recipient";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "transfer";
+    readonly outputs: readonly [];
+}];
+export declare const gh434ABI: readonly [{
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "bar";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "string";
+        readonly type: "string";
+    }];
+}, {
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "baz";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "foo";
+    readonly outputs: readonly [{
+        readonly name: "a";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }, {
+        readonly name: "b";
+        readonly internalType: "bool";
+        readonly type: "bool";
+    }];
+}];
+export declare const ensAvatarTokenUriABI: readonly [{
+    readonly stateMutability: "view";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "ownerOf";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+}, {
+    readonly stateMutability: "view";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "tokenId";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "tokenURI";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "string";
+        readonly type: "string";
+    }];
+}];
+export declare const errorsExampleABI: readonly [{
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "foo";
+        readonly internalType: "struct ErrorsExample.Foo";
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly name: "sender";
+            readonly internalType: "address";
+            readonly type: "address";
+        }, {
+            readonly name: "bar";
+            readonly internalType: "uint256";
+            readonly type: "uint256";
+        }];
+    }, {
+        readonly name: "message";
+        readonly internalType: "string";
+        readonly type: "string";
+    }, {
+        readonly name: "number";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "ComplexError";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "message";
+        readonly internalType: "string";
+        readonly type: "string";
+    }];
+    readonly name: "SimpleError";
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [];
+    readonly name: "SimpleErrorNoArgs";
+}, {
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "assertRead";
+    readonly outputs: readonly [];
+}, {
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "assertWrite";
+    readonly outputs: readonly [];
+}, {
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "complexCustomRead";
+    readonly outputs: readonly [];
+}, {
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "complexCustomWrite";
+    readonly outputs: readonly [];
+}, {
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "divideByZeroRead";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "divideByZeroWrite";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "overflowRead";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "overflowWrite";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "requireRead";
+    readonly outputs: readonly [];
+}, {
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "requireWrite";
+    readonly outputs: readonly [];
+}, {
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "revertRead";
+    readonly outputs: readonly [];
+}, {
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "revertWrite";
+    readonly outputs: readonly [];
+}, {
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "simpleCustomRead";
+    readonly outputs: readonly [];
+}, {
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "simpleCustomReadNoArgs";
+    readonly outputs: readonly [];
+}, {
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "simpleCustomWrite";
+    readonly outputs: readonly [];
+}];
+export declare const offchainLookupExampleABI: readonly [{
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+    readonly inputs: readonly [{
+        readonly name: "urls_";
+        readonly internalType: "string[]";
+        readonly type: "string[]";
+    }];
+}, {
+    readonly type: "error";
+    readonly inputs: readonly [{
+        readonly name: "sender";
+        readonly internalType: "address";
+        readonly type: "address";
+    }, {
+        readonly name: "urls";
+        readonly internalType: "string[]";
+        readonly type: "string[]";
+    }, {
+        readonly name: "callData";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }, {
+        readonly name: "callbackFunction";
+        readonly internalType: "bytes4";
+        readonly type: "bytes4";
+    }, {
+        readonly name: "extraData";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }];
+    readonly name: "OffchainLookup";
+}, {
+    readonly stateMutability: "view";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "name";
+        readonly internalType: "string";
+        readonly type: "string";
+    }];
+    readonly name: "getAddress";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+}, {
+    readonly stateMutability: "view";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "result";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }, {
+        readonly name: "extraData";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }];
+    readonly name: "getAddressWithProof";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+}, {
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "_ethSignedMessageHash";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "_signature";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }];
+    readonly name: "recoverSigner";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "address";
+        readonly type: "address";
+    }];
+}, {
+    readonly stateMutability: "pure";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "sig";
+        readonly internalType: "bytes";
+        readonly type: "bytes";
+    }];
+    readonly name: "splitSignature";
+    readonly outputs: readonly [{
+        readonly name: "r";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "s";
+        readonly internalType: "bytes32";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "v";
+        readonly internalType: "uint8";
+        readonly type: "uint8";
+    }];
+}, {
+    readonly stateMutability: "view";
+    readonly type: "function";
+    readonly inputs: readonly [{
+        readonly name: "";
+        readonly internalType: "uint256";
+        readonly type: "uint256";
+    }];
+    readonly name: "urls";
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly internalType: "string";
+        readonly type: "string";
+    }];
+}];
+export declare const payableABI: readonly [{
+    readonly stateMutability: "payable";
+    readonly type: "function";
+    readonly inputs: readonly [];
+    readonly name: "pay";
+    readonly outputs: readonly [];
+}];
+//# sourceMappingURL=generated.d.ts.map

package/_types/_test/generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated.d.ts","sourceRoot":"","sources":["../../_test/generated.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;EAWpB,CAAA;AAMV,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBf,CAAA;AAMV,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B/B,CAAA;AAMV,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBX,CAAA;AAMV,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAevB,CAAA;AAMV,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAiInB,CAAA;AAMV,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAkE3B,CAAA;AAMV,eAAO,MAAM,UAAU;;;;;;EAQb,CAAA"}

package/_types/accounts/generateMnemonic.d.ts

@@ -0,0 +1,12 @@
+import type { ErrorType } from '../errors/utils.js';
+export type GenerateMnemonicErrorType = ErrorType;
+/**
+ * @description Generates a random mnemonic phrase with a given wordlist.
+ *
+ * @param wordlist The wordlist to use for generating the mnemonic phrase.
+ * @param strength mnemonic strength 128-256 bits
+ *
+ * @returns A randomly generated mnemonic phrase.
+ */
+export declare function generateMnemonic(wordlist: string[], strength?: number): string;
+//# sourceMappingURL=generateMnemonic.d.ts.map

package/_types/accounts/generateMnemonic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateMnemonic.d.ts","sourceRoot":"","sources":["../../accounts/generateMnemonic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAEnD,MAAM,MAAM,yBAAyB,GAAG,SAAS,CAAA;AAEjD;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,MAAM,EAAE,EAClB,QAAQ,CAAC,EAAE,MAAM,GAChB,MAAM,CAER"}

package/_types/accounts/generatePrivateKey.d.ts

@@ -0,0 +1,11 @@
+import type { ErrorType } from '../errors/utils.js';
+import type { Hex } from '../types/misc.js';
+import { type ToHexErrorType } from '../utils/encoding/toHex.js';
+export type GeneratePrivateKeyErrorType = ToHexErrorType | ErrorType;
+/**
+ * @description Generates a random private key.
+ *
+ * @returns A randomly generated private key.
+ */
+export declare function generatePrivateKey(): Hex;
+//# sourceMappingURL=generatePrivateKey.d.ts.map

package/_types/accounts/generatePrivateKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generatePrivateKey.d.ts","sourceRoot":"","sources":["../../accounts/generatePrivateKey.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,KAAK,cAAc,EAAS,MAAM,4BAA4B,CAAA;AAEvE,MAAM,MAAM,2BAA2B,GAAG,cAAc,GAAG,SAAS,CAAA;AAEpE;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,GAAG,CAExC"}

package/_types/accounts/hdKeyToAccount.d.ts

@@ -0,0 +1,13 @@
+import type { HDKey } from '@scure/bip32';
+import { type ToHexErrorType } from '../utils/encoding/toHex.js';
+import type { ErrorType } from '../errors/utils.js';
+import { type PrivateKeyToAccountErrorType } from './privateKeyToAccount.js';
+import type { HDAccount, HDOptions } from './types.js';
+export type HDKeyToAccountErrorType = PrivateKeyToAccountErrorType | ToHexErrorType | ErrorType;
+/**
+ * @description Creates an Account from a HD Key.
+ *
+ * @returns A HD Account.
+ */
+export declare function hdKeyToAccount(hdKey_: HDKey, { accountIndex, addressIndex, changeIndex, path }?: HDOptions): HDAccount;
+//# sourceMappingURL=hdKeyToAccount.d.ts.map

package/_types/accounts/hdKeyToAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hdKeyToAccount.d.ts","sourceRoot":"","sources":["../../accounts/hdKeyToAccount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AAEzC,OAAO,EAAE,KAAK,cAAc,EAAS,MAAM,4BAA4B,CAAA;AAEvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,EACL,KAAK,4BAA4B,EAElC,MAAM,0BAA0B,CAAA;AACjC,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAEtD,MAAM,MAAM,uBAAuB,GAC/B,4BAA4B,GAC5B,cAAc,GACd,SAAS,CAAA;AAEb;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,KAAK,EACb,EAAE,YAAgB,EAAE,YAAgB,EAAE,WAAe,EAAE,IAAI,EAAE,GAAE,SAAc,GAC5E,SAAS,CAUX"}

package/_types/accounts/index.d.ts

@@ -0,0 +1,27 @@
+export type { Address } from 'abitype';
+export { HDKey } from '@scure/bip32';
+export { wordlist as czech } from '@scure/bip39/wordlists/czech';
+export { wordlist as english } from '@scure/bip39/wordlists/english';
+export { wordlist as french } from '@scure/bip39/wordlists/french';
+export { wordlist as italian } from '@scure/bip39/wordlists/italian';
+export { wordlist as japanese } from '@scure/bip39/wordlists/japanese';
+export { wordlist as korean } from '@scure/bip39/wordlists/korean';
+export { wordlist as simplifiedChinese } from '@scure/bip39/wordlists/simplified-chinese';
+export { wordlist as spanish } from '@scure/bip39/wordlists/spanish';
+export { wordlist as traditionalChinese } from '@scure/bip39/wordlists/traditional-chinese';
+export { type GenerateMnemonicErrorType, generateMnemonic, } from './generateMnemonic.js';
+export { type GeneratePrivateKeyErrorType, generatePrivateKey, } from './generatePrivateKey.js';
+export { type HDKeyToAccountErrorType, hdKeyToAccount, } from './hdKeyToAccount.js';
+export { type MnemonicToAccountErrorType, mnemonicToAccount, } from './mnemonicToAccount.js';
+export { type PrivateKeyToAccountErrorType, privateKeyToAccount, } from './privateKeyToAccount.js';
+export { type ToAccountErrorType, toAccount } from './toAccount.js';
+export type { Account, AccountSource, CustomSource, HDOptions, JsonRpcAccount, LocalAccount, HDAccount, PrivateKeyAccount, } from './types.js';
+export { type SignErrorType, type SignParameters, type SignReturnType, sign, } from './utils/sign.js';
+export { type SignatureToHexErrorType, signatureToHex, } from '../utils/signature/signatureToHex.js';
+export { type SignMessageErrorType, type SignMessageParameters, type SignMessageReturnType, signMessage, } from './utils/signMessage.js';
+export { type SignTransactionErrorType, type SignTransactionParameters, type SignTransactionReturnType, signTransaction, } from './utils/signTransaction.js';
+export { type SignTypedDataErrorType, type SignTypedDataParameters, type SignTypedDataReturnType, signTypedData, } from './utils/signTypedData.js';
+export { type ParseAccountErrorType, parseAccount, } from './utils/parseAccount.js';
+export { type PublicKeyToAddressErrorType, publicKeyToAddress, } from './utils/publicKeyToAddress.js';
+export { type PrivateKeyToAddressErrorType, privateKeyToAddress, } from './utils/privateKeyToAddress.js';
+//# sourceMappingURL=index.d.ts.map

package/_types/accounts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../accounts/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAA;AACpC,OAAO,EAAE,QAAQ,IAAI,KAAK,EAAE,MAAM,8BAA8B,CAAA;AAChE,OAAO,EAAE,QAAQ,IAAI,OAAO,EAAE,MAAM,gCAAgC,CAAA;AACpE,OAAO,EAAE,QAAQ,IAAI,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAClE,OAAO,EAAE,QAAQ,IAAI,OAAO,EAAE,MAAM,gCAAgC,CAAA;AACpE,OAAO,EAAE,QAAQ,IAAI,QAAQ,EAAE,MAAM,iCAAiC,CAAA;AACtE,OAAO,EAAE,QAAQ,IAAI,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAClE,OAAO,EAAE,QAAQ,IAAI,iBAAiB,EAAE,MAAM,2CAA2C,CAAA;AACzF,OAAO,EAAE,QAAQ,IAAI,OAAO,EAAE,MAAM,gCAAgC,CAAA;AACpE,OAAO,EAAE,QAAQ,IAAI,kBAAkB,EAAE,MAAM,4CAA4C,CAAA;AAE3F,OAAO,EACL,KAAK,yBAAyB,EAC9B,gBAAgB,GACjB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,KAAK,2BAA2B,EAChC,kBAAkB,GACnB,MAAM,yBAAyB,CAAA;AAChC,OAAO,EACL,KAAK,uBAAuB,EAC5B,cAAc,GACf,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EACL,KAAK,0BAA0B,EAC/B,iBAAiB,GAClB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EACL,KAAK,4BAA4B,EACjC,mBAAmB,GACpB,MAAM,0BAA0B,CAAA;AACjC,OAAO,EAAE,KAAK,kBAAkB,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AACnE,YAAY,EACV,OAAO,EACP,aAAa,EACb,YAAY,EACZ,SAAS,EACT,cAAc,EACd,YAAY,EACZ,SAAS,EACT,iBAAiB,GAClB,MAAM,YAAY,CAAA;AACnB,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,cAAc,EACnB,IAAI,GACL,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,KAAK,uBAAuB,EAC5B,cAAc,GACf,MAAM,sCAAsC,CAAA;AAC7C,OAAO,EACL,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC1B,KAAK,qBAAqB,EAC1B,WAAW,GACZ,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EAC9B,eAAe,GAChB,MAAM,4BAA4B,CAAA;AACnC,OAAO,EACL,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,aAAa,GACd,MAAM,0BAA0B,CAAA;AACjC,OAAO,EACL,KAAK,qBAAqB,EAC1B,YAAY,GACb,MAAM,yBAAyB,CAAA;AAChC,OAAO,EACL,KAAK,2BAA2B,EAChC,kBAAkB,GACnB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EACL,KAAK,4BAA4B,EACjC,mBAAmB,GACpB,MAAM,gCAAgC,CAAA"}

package/_types/accounts/mnemonicToAccount.d.ts

@@ -0,0 +1,11 @@
+import type { ErrorType } from '../errors/utils.js';
+import { type HDKeyToAccountErrorType } from './hdKeyToAccount.js';
+import type { HDAccount, HDOptions } from './types.js';
+export type MnemonicToAccountErrorType = HDKeyToAccountErrorType | ErrorType;
+/**
+ * @description Creates an Account from a mnemonic phrase.
+ *
+ * @returns A HD Account.
+ */
+export declare function mnemonicToAccount(mnemonic: string, opts?: HDOptions): HDAccount;
+//# sourceMappingURL=mnemonicToAccount.d.ts.map

package/_types/accounts/mnemonicToAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mnemonicToAccount.d.ts","sourceRoot":"","sources":["../../accounts/mnemonicToAccount.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,EACL,KAAK,uBAAuB,EAE7B,MAAM,qBAAqB,CAAA;AAC5B,OAAO,KAAK,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,YAAY,CAAA;AAEtD,MAAM,MAAM,0BAA0B,GAAG,uBAAuB,GAAG,SAAS,CAAA;AAE5E;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE,SAAc,GACnB,SAAS,CAGX"}

package/_types/accounts/privateKeyToAccount.d.ts

@@ -0,0 +1,17 @@
+import type { Hex } from '../types/misc.js';
+import { type ToHexErrorType } from '../utils/encoding/toHex.js';
+import type { ErrorType } from '../errors/utils.js';
+import { type ToAccountErrorType } from './toAccount.js';
+import type { PrivateKeyAccount } from './types.js';
+import { type PublicKeyToAddressErrorType } from './utils/publicKeyToAddress.js';
+import { type SignMessageErrorType } from './utils/signMessage.js';
+import { type SignTransactionErrorType } from './utils/signTransaction.js';
+import { type SignTypedDataErrorType } from './utils/signTypedData.js';
+export type PrivateKeyToAccountErrorType = ToAccountErrorType | ToHexErrorType | PublicKeyToAddressErrorType | SignMessageErrorType | SignTransactionErrorType | SignTypedDataErrorType | ErrorType;
+/**
+ * @description Creates an Account from a private key.
+ *
+ * @returns A Private Key Account.
+ */
+export declare function privateKeyToAccount(privateKey: Hex): PrivateKeyAccount;
+//# sourceMappingURL=privateKeyToAccount.d.ts.map

package/_types/accounts/privateKeyToAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"privateKeyToAccount.d.ts","sourceRoot":"","sources":["../../accounts/privateKeyToAccount.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAC3C,OAAO,EAAE,KAAK,cAAc,EAAS,MAAM,4BAA4B,CAAA;AAEvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAE,KAAK,kBAAkB,EAAa,MAAM,gBAAgB,CAAA;AACnE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EACL,KAAK,2BAA2B,EAEjC,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAAE,KAAK,oBAAoB,EAAe,MAAM,wBAAwB,CAAA;AAC/E,OAAO,EACL,KAAK,wBAAwB,EAE9B,MAAM,4BAA4B,CAAA;AACnC,OAAO,EACL,KAAK,sBAAsB,EAE5B,MAAM,0BAA0B,CAAA;AAEjC,MAAM,MAAM,4BAA4B,GACpC,kBAAkB,GAClB,cAAc,GACd,2BAA2B,GAC3B,oBAAoB,GACpB,wBAAwB,GACxB,sBAAsB,GACtB,SAAS,CAAA;AAEb;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,GAAG,GAAG,iBAAiB,CAsBtE"}

package/_types/accounts/toAccount.d.ts

@@ -0,0 +1,15 @@
+import type { Address } from 'abitype';
+import { type InvalidAddressErrorType } from '../errors/address.js';
+import { type IsAddressErrorType } from '../utils/address/isAddress.js';
+import type { ErrorType } from '../errors/utils.js';
+import type { AccountSource, CustomSource, JsonRpcAccount, LocalAccount } from './types.js';
+type GetAccountReturnType<TAccountSource extends AccountSource> = (TAccountSource extends Address ? JsonRpcAccount : never) | (TAccountSource extends CustomSource ? LocalAccount : never);
+export type ToAccountErrorType = InvalidAddressErrorType | IsAddressErrorType | ErrorType;
+/**
+ * @description Creates an Account from a custom signing implementation.
+ *
+ * @returns A Local Account.
+ */
+export declare function toAccount<TAccountSource extends AccountSource>(source: TAccountSource): GetAccountReturnType<TAccountSource>;
+export {};
+//# sourceMappingURL=toAccount.d.ts.map

package/_types/accounts/toAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toAccount.d.ts","sourceRoot":"","sources":["../../accounts/toAccount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEtC,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EACL,KAAK,kBAAkB,EAExB,MAAM,+BAA+B,CAAA;AAEtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,cAAc,EACd,YAAY,EACb,MAAM,YAAY,CAAA;AAEnB,KAAK,oBAAoB,CAAC,cAAc,SAAS,aAAa,IAC1D,CAAC,cAAc,SAAS,OAAO,GAAG,cAAc,GAAG,KAAK,CAAC,GACzD,CAAC,cAAc,SAAS,YAAY,GAAG,YAAY,GAAG,KAAK,CAAC,CAAA;AAEhE,MAAM,MAAM,kBAAkB,GAC1B,uBAAuB,GACvB,kBAAkB,GAClB,SAAS,CAAA;AAEb;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,cAAc,SAAS,aAAa,EAC5D,MAAM,EAAE,cAAc,GACrB,oBAAoB,CAAC,cAAc,CAAC,CAmBtC"}

package/_types/accounts/types.d.ts

@@ -0,0 +1,50 @@
+import type { HDKey } from '@scure/bip32';
+import type { Address, TypedData } from 'abitype';
+import type { Hash, Hex, SignableMessage } from '../types/misc.js';
+import type { TransactionSerializable, TransactionSerialized } from '../types/transaction.js';
+import type { TypedDataDefinition } from '../types/typedData.js';
+import type { IsNarrowable } from '../types/utils.js';
+import type { GetTransactionType } from '../utils/transaction/getTransactionType.js';
+import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js';
+export type Account<TAddress extends Address = Address> = JsonRpcAccount<TAddress> | LocalAccount<string, TAddress>;
+export type AccountSource = Address | CustomSource;
+export type CustomSource = {
+    address: Address;
+    signMessage: ({ message }: {
+        message: SignableMessage;
+    }) => Promise<Hash>;
+    signTransaction: <TTransactionSerializable extends TransactionSerializable>(transaction: TTransactionSerializable, args?: {
+        serializer?: SerializeTransactionFn<TTransactionSerializable>;
+    }) => Promise<IsNarrowable<TransactionSerialized<GetTransactionType<TTransactionSerializable>>, Hash> extends true ? TransactionSerialized<GetTransactionType<TTransactionSerializable>> : Hash>;
+    signTypedData: <const typedData extends TypedData | Record<string, unknown>, primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData>(typedDataDefinition: TypedDataDefinition<typedData, primaryType>) => Promise<Hash>;
+};
+export type JsonRpcAccount<TAddress extends Address = Address> = {
+    address: TAddress;
+    type: 'json-rpc';
+};
+export type LocalAccount<TSource extends string = 'custom', TAddress extends Address = Address> = CustomSource & {
+    address: TAddress;
+    publicKey: Hex;
+    source: TSource;
+    type: 'local';
+};
+export type HDAccount = LocalAccount<'hd'> & {
+    getHdKey(): HDKey;
+};
+export type HDOptions = {
+    /** The account index to use in the path (`"m/44'/60'/${accountIndex}'/0/0"`). */
+    accountIndex?: number;
+    /** The address index to use in the path (`"m/44'/60'/0'/0/${addressIndex}"`). */
+    addressIndex?: number;
+    /** The change index to use in the path (`"m/44'/60'/0'/${changeIndex}/0"`). */
+    changeIndex?: number;
+    path?: never;
+} | {
+    accountIndex?: never;
+    addressIndex?: never;
+    changeIndex?: never;
+    /** The HD path. */
+    path: `m/44'/60'/${string}`;
+};
+export type PrivateKeyAccount = LocalAccount<'privateKey'>;
+//# sourceMappingURL=types.d.ts.map

package/_types/accounts/types.d.ts.map

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

package/_types/accounts/utils/parseAccount.d.ts

@@ -0,0 +1,6 @@
+import type { Address } from 'abitype';
+import type { ErrorType } from '../../errors/utils.js';
+import type { Account } from '../types.js';
+export type ParseAccountErrorType = ErrorType;
+export declare function parseAccount(account: Address | Account): Account;
+//# sourceMappingURL=parseAccount.d.ts.map

package/_types/accounts/utils/parseAccount.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseAccount.d.ts","sourceRoot":"","sources":["../../../accounts/utils/parseAccount.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AAEtC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAA;AACtD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,aAAa,CAAA;AAE1C,MAAM,MAAM,qBAAqB,GAAG,SAAS,CAAA;AAE7C,wBAAgB,YAAY,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAGhE"}