{"version":3,"sources":["../../src/seed-phrase/index.ts","../../src/crypto/key_pair_base.ts","../../src/crypto/key_pair_ed25519.ts","../../src/utils/format.ts","../../src/crypto/constants.ts","../../src/crypto/public_key.ts","../../src/crypto/key_pair_ml_dsa_65.ts","../../src/crypto/key_pair_secp256k1.ts","../../src/crypto/key_pair.ts"],"sourcesContent":["import {\n    generateSeedPhrase as internalGenerateSeedPhrase,\n    parseSeedPhrase as internalParseSeedPhrase,\n} from 'near-seed-phrase';\nimport type { KeyPairString } from '../crypto/constants.js';\nimport { KeyPair } from '../crypto/key_pair.js';\n\nexport function parseSeedPhrase(seedPhrase: string): KeyPair {\n    const { secretKey } = internalParseSeedPhrase(seedPhrase);\n\n    return KeyPair.fromString(secretKey as KeyPairString);\n}\n\nexport function generateSeedPhrase(): { seedPhrase: string; keyPair: KeyPair } {\n    const { seedPhrase, secretKey } = internalGenerateSeedPhrase();\n\n    return {\n        seedPhrase,\n        keyPair: KeyPair.fromString(secretKey as KeyPairString),\n    };\n}\n","import type { KeyPairString } from './constants.js';\nimport type { PublicKey } from './public_key.js';\n\nexport interface Signature {\n    signature: Uint8Array;\n    publicKey: PublicKey;\n}\n\nexport abstract class KeyPairBase {\n    abstract sign(message: Uint8Array): Signature;\n    abstract verify(message: Uint8Array, signature: Uint8Array): boolean;\n    abstract toString(): KeyPairString;\n    abstract getPublicKey(): PublicKey;\n}\n","import { ed25519 } from '@noble/curves/ed25519.js';\nimport { baseDecode, baseEncode } from '../utils/index.js';\n\nimport { type KeyPairString, KeySize, KeyType } from './constants.js';\nimport { KeyPairBase, type Signature } from './key_pair_base.js';\nimport { PublicKey } from './public_key.js';\n\n/**\n * This class provides key pair functionality for Ed25519 curve:\n * generating key pairs, encoding key pairs, signing and verifying.\n */\nexport class KeyPairEd25519 extends KeyPairBase {\n    readonly publicKey: PublicKey;\n    readonly secretKey: string;\n    readonly extendedSecretKey: string;\n\n    /**\n     * Construct an instance of key pair given a secret key.\n     * It's generally assumed that these are encoded in base58.\n     * @param extendedSecretKey\n     */\n    constructor(extendedSecretKey: string) {\n        super();\n        const decoded = baseDecode(extendedSecretKey);\n        const secretKey = new Uint8Array(decoded.slice(0, KeySize.SECRET_KEY));\n        const publicKey = ed25519.getPublicKey(new Uint8Array(secretKey));\n        this.publicKey = new PublicKey({ keyType: KeyType.ED25519, data: publicKey });\n        this.secretKey = baseEncode(secretKey);\n        this.extendedSecretKey = extendedSecretKey;\n    }\n\n    /**\n     * Generate a new random keypair.\n     * @example\n     * const keyRandom = KeyPair.fromRandom();\n     * keyRandom.publicKey\n     * // returns [PUBLIC_KEY]\n     *\n     * keyRandom.secretKey\n     * // returns [SECRET_KEY]\n     */\n    static fromRandom() {\n        const secretKey = crypto.getRandomValues(new Uint8Array(KeySize.SECRET_KEY));\n        const publicKey = ed25519.getPublicKey(new Uint8Array(secretKey));\n        const extendedSecretKey = new Uint8Array([...secretKey, ...publicKey]);\n        return new KeyPairEd25519(baseEncode(extendedSecretKey));\n    }\n\n    /**\n     * Signs a message using the key pair's secret key.\n     * @param message The message to be signed.\n     * @returns {Signature} The signature object containing the signature and the public key.\n     */\n    sign(message: Uint8Array): Signature {\n        const signature = ed25519.sign(message, baseDecode(this.secretKey));\n        return { signature, publicKey: this.publicKey };\n    }\n\n    /**\n     * Verifies the signature of a message using the key pair's public key.\n     * @param message The message to be verified.\n     * @param signature The signature to be verified.\n     * @returns {boolean} `true` if the signature is valid, otherwise `false`.\n     */\n    verify(message: Uint8Array, signature: Uint8Array): boolean {\n        return this.publicKey.verify(message, signature);\n    }\n\n    /**\n     * Returns a string representation of the key pair in the format 'ed25519:[extendedSecretKey]'.\n     * @returns {string} The string representation of the key pair.\n     */\n    toString(): KeyPairString {\n        return `ed25519:${this.extendedSecretKey}`;\n    }\n\n    /**\n     * Retrieves the public key associated with the key pair.\n     * @returns {PublicKey} The public key.\n     */\n    getPublicKey(): PublicKey {\n        return this.publicKey;\n    }\n}\n","import { base58, base64 } from '@scure/base';\n\ntype NumericString = `${number}`;\n\n/**\n * Exponent for calculating how many indivisible units are there in one NEAR. See {@link NEAR_NOMINATION}.\n */\nexport const NEAR_NOMINATION_EXP = 24;\n\n/**\n * Number of indivisible units in one NEAR. Derived from {@link NEAR_NOMINATION_EXP}.\n */\nexport const NEAR_NOMINATION = 10n ** BigInt(NEAR_NOMINATION_EXP);\n\n// Pre-calculate offsets used for rounding to different number of digits\nconst ROUNDING_OFFSETS: bigint[] = [];\nconst BN10 = 10n;\nfor (let i = 0, offset = 5n; i < NEAR_NOMINATION_EXP; i++, offset = offset * BN10) {\n    ROUNDING_OFFSETS[i] = offset;\n}\n\n/**\n * @deprecated use {@link units!yoctoToNear} from 'near-api-js' instead.\n *\n * Convert account balance value from internal indivisible units to NEAR. 1 NEAR is defined by {@link NEAR_NOMINATION}.\n * Effectively this divides given amount by {@link NEAR_NOMINATION}.\n *\n * @param balance decimal string representing balance in smallest non-divisible NEAR units (as specified by {@link NEAR_NOMINATION})\n * @param fracDigits number of fractional digits to preserve in formatted string. Balance is rounded to match given number of digits.\n * @returns Value in Ⓝ\n */\nexport function formatNearAmount(balance: string | number | bigint, fracDigits: number = NEAR_NOMINATION_EXP): string {\n    let balanceBN = BigInt(balance);\n    if (fracDigits !== NEAR_NOMINATION_EXP) {\n        // Adjust balance for rounding at given number of digits\n        const roundingExp = NEAR_NOMINATION_EXP - fracDigits - 1;\n        if (roundingExp > 0) {\n            balanceBN += ROUNDING_OFFSETS[roundingExp]!;\n        }\n    }\n\n    balance = balanceBN.toString();\n    const wholeStr = balance.substring(0, balance.length - NEAR_NOMINATION_EXP) || '0';\n    const fractionStr = balance\n        .substring(balance.length - NEAR_NOMINATION_EXP)\n        .padStart(NEAR_NOMINATION_EXP, '0')\n        .substring(0, fracDigits);\n\n    return trimTrailingZeroes(`${formatWithCommas(wholeStr)}.${fractionStr}`);\n}\n\n/**\n * @deprecated use {@link units!nearToYocto} from 'near-api-js' instead.\n *\n * Convert human readable NEAR amount to internal indivisible units.\n * Effectively this multiplies given amount by {@link NEAR_NOMINATION}.\n *\n * @param amount decimal string (potentially fractional) denominated in NEAR.\n * @returns The parsed yoctoⓃ amount\n * @throws {Error} if the amount is empty or invalid\n */\nexport function parseNearAmount(amount: NumericString | number): string {\n    const cleanedAmount = cleanupAmount(amount.toString());\n    if (!cleanedAmount) {\n        throw new Error('Amount cannot be empty');\n    }\n    const split = cleanedAmount.split('.');\n    const wholePart = split[0];\n    const fracPart = split[1] || '';\n    if (split.length > 2 || fracPart.length > NEAR_NOMINATION_EXP) {\n        throw new Error(`Cannot parse '${amount}' as NEAR amount`);\n    }\n    return trimLeadingZeroes(wholePart + fracPart.padEnd(NEAR_NOMINATION_EXP, '0'));\n}\n\n/**\n * Removes commas from the input\n * @param amount A value or amount that may contain commas\n * @returns string The cleaned value\n */\nfunction cleanupAmount(amount: string): string {\n    return amount.replace(/,/g, '').trim();\n}\n\n/**\n * Removes .000… from an input\n * @param value A value that may contain trailing zeroes in the decimals place\n * @returns string The value without the trailing zeros\n */\nfunction trimTrailingZeroes(value: string): string {\n    return value.replace(/\\.?0*$/, '');\n}\n\n/**\n * Removes leading zeroes from an input\n * @param value A value that may contain leading zeroes\n * @returns string The value without the leading zeroes\n */\nfunction trimLeadingZeroes(value: string): string {\n    value = value.replace(/^0+/, '');\n    if (value === '') {\n        return '0';\n    }\n    return value;\n}\n\n/**\n * Returns a human-readable value with commas\n * @param value A value that may not contain commas\n * @returns string A value with commas\n */\nfunction formatWithCommas(value: string): string {\n    const pattern = /(-?\\d+)(\\d{3})/;\n    while (pattern.test(value)) {\n        value = value.replace(pattern, '$1,$2');\n    }\n    return value;\n}\n\n/**\n * Encodes a Uint8Array or string into base58\n * @param value Uint8Array or string representing a borsh encoded object\n * @returns string base58 encoding of the value\n */\nexport function baseEncode(value: Uint8Array | string): string {\n    if (typeof value === 'string') {\n        const bytes: number[] = [];\n        for (let c = 0; c < value.length; c++) {\n            bytes.push(value.charCodeAt(c));\n        }\n        value = new Uint8Array(bytes);\n    }\n    return base58.encode(value);\n}\n\n/**\n * Decodes a base58 string into a Uint8Array\n * @param value base58 encoded string\n * @returns Uint8Array representing the decoded value\n */\nexport function baseDecode(value: string): Uint8Array {\n    return base58.decode(value);\n}\n\n/**\n * Encodes a Uint8Array into a base64 string\n * @param bytes Uint8Array to encode\n * @returns base64 encoded string\n */\nexport function base64Encode(bytes: Uint8Array): string {\n    return base64.encode(bytes);\n}\n\n/**\n * Decodes a base64 string into a Uint8Array\n * @param str base64 encoded string\n * @returns Uint8Array representing the decoded value\n */\nexport function base64Decode(str: string): Uint8Array {\n    return base64.decode(str);\n}\n\nconst encoder = new TextEncoder();\nconst decoder = new TextDecoder();\n\n/**\n * Encodes a string into a Uint8Array using UTF-8\n * @param str string to encode\n * @returns Uint8Array representing the UTF-8 bytes\n */\nexport function stringToBytes(str: string): Uint8Array {\n    return encoder.encode(str);\n}\n\n/**\n * Decodes a Uint8Array into a string using UTF-8\n * @param bytes Uint8Array to decode\n * @returns decoded string\n */\nexport function bytesToString(bytes: Uint8Array): string {\n    return decoder.decode(bytes);\n}\n","/** All supported key types */\nexport enum KeyType {\n    ED25519 = 0,\n    SECP256K1 = 1,\n    MLDSA65 = 2,\n}\n\nexport const KeySize = {\n    SECRET_KEY: 32,\n    ED25519_PUBLIC_KEY: 32,\n    SECP256k1_PUBLIC_KEY: 64,\n    MLDSA65_PUBLIC_KEY: 1952,\n    MLDSA65_SIGNATURE: 3309,\n};\n\nexport type CurveType = 'ed25519' | 'ED25519' | 'secp256k1' | 'SECP256K1' | 'ml-dsa-65' | 'ML-DSA-65';\n\nexport type KeyPairString = `ed25519:${string}` | `secp256k1:${string}` | `ml-dsa-65:${string}`;\n","import { ed25519 } from '@noble/curves/ed25519.js';\nimport { secp256k1 } from '@noble/curves/secp256k1.js';\nimport { ml_dsa65 } from '@noble/post-quantum/ml-dsa.js';\nimport { baseDecode, baseEncode } from '../utils/index.js';\n\nimport { KeySize, KeyType } from './constants.js';\n\nfunction key_type_to_str(keyType: KeyType): string {\n    switch (keyType) {\n        case KeyType.ED25519:\n            return 'ed25519';\n        case KeyType.SECP256K1:\n            return 'secp256k1';\n        case KeyType.MLDSA65:\n            return 'ml-dsa-65';\n        default:\n            throw new Error(`Unknown key type ${keyType}`);\n    }\n}\n\nfunction str_to_key_type(keyType: string): KeyType {\n    switch (keyType.toLowerCase()) {\n        case 'ed25519':\n            return KeyType.ED25519;\n        case 'secp256k1':\n            return KeyType.SECP256K1;\n        case 'ml-dsa-65':\n            return KeyType.MLDSA65;\n        default:\n            throw new Error(`Unknown key type ${keyType}`);\n    }\n}\n\nclass ED25519PublicKey {\n    keyType: KeyType = KeyType.ED25519;\n    data!: Uint8Array;\n}\nclass SECP256K1PublicKey {\n    keyType: KeyType = KeyType.SECP256K1;\n    data!: Uint8Array;\n}\nclass MLDSA65PublicKey {\n    keyType: KeyType = KeyType.MLDSA65;\n    data!: Uint8Array;\n}\n\nfunction resolveEnumKeyName(keyType: KeyType) {\n    switch (keyType) {\n        case KeyType.ED25519: {\n            return 'ed25519Key';\n        }\n        case KeyType.SECP256K1: {\n            return 'secp256k1Key';\n        }\n        case KeyType.MLDSA65: {\n            return 'mlDsa65Key';\n        }\n        default: {\n            throw Error(`unknown type ${keyType}`);\n        }\n    }\n}\n\n/**\n * DUPLICATED FROM @near-js/types - REPLACE WITH IMPORTED REFERENCE AND DELETE\n * This ends up being necessary for Wallet Selector dependencies with\n * outdated peer dependencies and should only be temporary\n */\nabstract class Enum {\n    abstract enum: string;\n\n    constructor(properties: any) {\n        if (Object.keys(properties).length !== 1) {\n            throw new Error('Enum can only take single value');\n        }\n        Object.keys(properties).forEach((key: string) => {\n            (this as any)[key] = properties[key];\n        });\n    }\n}\n\n/**\n * PublicKey representation that has type and bytes of the key.\n */\n\nexport class PublicKey extends Enum {\n    enum: string;\n    ed25519Key?: ED25519PublicKey;\n    secp256k1Key?: SECP256K1PublicKey;\n    mlDsa65Key?: MLDSA65PublicKey;\n\n    constructor(publicKey: { keyType: KeyType; data: Uint8Array }) {\n        const keyName = resolveEnumKeyName(publicKey.keyType);\n        super({ [keyName]: publicKey });\n        this[keyName] = publicKey;\n        this.enum = keyName;\n    }\n\n    /**\n     * Creates a PublicKey instance from a string or an existing PublicKey instance.\n     * @param value The string or PublicKey instance to create a PublicKey from.\n     * @returns {PublicKey} The PublicKey instance.\n     */\n    static from(value: string | PublicKey): PublicKey;\n    static from(value: string | PublicKey | Record<string, unknown>): PublicKey {\n        if (typeof value === 'string') {\n            return PublicKey.fromString(value);\n        }\n\n        if (value instanceof PublicKey) {\n            return value;\n        }\n\n        if (typeof value === 'object' && value !== null) {\n            const maybeEd25519 = value['ed25519Key'];\n            if (typeof maybeEd25519 === 'object' && maybeEd25519 !== null && 'data' in maybeEd25519) {\n                return new PublicKey({\n                    keyType: KeyType.ED25519,\n                    data: Uint8Array.from((maybeEd25519 as { data: Uint8Array | number[] }).data),\n                });\n            }\n\n            const maybeSecp256k1 = value['secp256k1Key'];\n            if (typeof maybeSecp256k1 === 'object' && maybeSecp256k1 !== null && 'data' in maybeSecp256k1) {\n                return new PublicKey({\n                    keyType: KeyType.SECP256K1,\n                    data: Uint8Array.from((maybeSecp256k1 as { data: Uint8Array | number[] }).data),\n                });\n            }\n\n            const maybeMlDsa65 = value['mlDsa65Key'];\n            if (typeof maybeMlDsa65 === 'object' && maybeMlDsa65 !== null && 'data' in maybeMlDsa65) {\n                return new PublicKey({\n                    keyType: KeyType.MLDSA65,\n                    data: Uint8Array.from((maybeMlDsa65 as { data: Uint8Array | number[] }).data),\n                });\n            }\n        }\n\n        throw new Error('Unsupported public key format');\n    }\n\n    /**\n     * Creates a PublicKey instance from an encoded key string.\n     * @param encodedKey The encoded key string.\n     * @returns {PublicKey} The PublicKey instance created from the encoded key string.\n     */\n    static fromString(encodedKey: string): PublicKey {\n        const parts = encodedKey.split(':');\n        let publicKey: string;\n        let keyType;\n        if (parts.length === 1) {\n            publicKey = parts[0]!;\n        } else if (parts.length === 2) {\n            publicKey = parts[1]!;\n            keyType = str_to_key_type(parts[0]!);\n        } else {\n            throw new Error('Invalid encoded key format, must be <curve>:<encoded key>');\n        }\n        const decodedPublicKey = baseDecode(publicKey);\n        if (!keyType) {\n            keyType = decodedPublicKey.length === KeySize.SECP256k1_PUBLIC_KEY ? KeyType.SECP256K1 : KeyType.ED25519;\n        }\n        const keySize =\n            keyType === KeyType.ED25519\n                ? KeySize.ED25519_PUBLIC_KEY\n                : keyType === KeyType.SECP256K1\n                  ? KeySize.SECP256k1_PUBLIC_KEY\n                  : KeySize.MLDSA65_PUBLIC_KEY;\n        if (decodedPublicKey.length !== keySize) {\n            throw new Error(`Invalid public key size (${decodedPublicKey.length}), must be ${keySize}`);\n        }\n        return new PublicKey({ keyType, data: decodedPublicKey });\n    }\n\n    /**\n     * Returns a string representation of the public key.\n     * @returns {string} The string representation of the public key.\n     */\n    override toString(): string {\n        const encodedKey = baseEncode(this.data);\n        return `${key_type_to_str(this.keyType)}:${encodedKey}`;\n    }\n\n    /**\n     * Verifies a message signature using the public key.\n     * @param message The message to be verified.\n     * @param signature The signature to be verified.\n     * @returns {boolean} `true` if the signature is valid, otherwise `false`.\n     */\n    verify(message: Uint8Array, signature: Uint8Array): boolean {\n        const keyType = this.keyType;\n        const data = this.data;\n        switch (keyType) {\n            case KeyType.ED25519:\n                return ed25519.verify(signature, message, data);\n            case KeyType.SECP256K1:\n                return secp256k1.verify(signature.subarray(0, 64), message, new Uint8Array([0x04, ...data]), {\n                    prehash: false,\n                });\n            case KeyType.MLDSA65:\n                return ml_dsa65.verify(signature, message, data);\n            default:\n                throw new Error(`Unknown key type: ${keyType}`);\n        }\n    }\n\n    get keyPair() {\n        return this.ed25519Key || this.secp256k1Key || this.mlDsa65Key;\n    }\n\n    get keyType(): KeyType {\n        if (typeof this.keyPair === 'undefined') throw new Error(`Property 'keyPair' of PublicKey is undefined`);\n\n        return this.keyPair.keyType;\n    }\n\n    get data(): Uint8Array {\n        if (typeof this.keyPair === 'undefined') throw new Error(`Property 'keyPair' of PublicKey is undefined`);\n\n        return this.keyPair.data;\n    }\n}\n\nexport function keyToImplicitAddress(publicKey: string | PublicKey): string {\n    const pk = PublicKey.from(publicKey);\n\n    const publicKeyWithoutPrefix = pk.toString().replace(/^ed25519:/, '');\n\n    const decoded = baseDecode(publicKeyWithoutPrefix);\n    // Converting to hex string is implemented manually\n    // to avoid issues with environments that do not support Buffer\n    let result = '';\n    for (let i = 0; i < decoded.length; i++) {\n        const hex = decoded[i]!.toString(16);\n        result += hex.length === 1 ? `0${hex}` : hex;\n    }\n    return result;\n}\n","import { ml_dsa65 } from '@noble/post-quantum/ml-dsa.js';\nimport { baseDecode, baseEncode } from '../utils/index.js';\n\nimport { type KeyPairString, KeyType } from './constants.js';\nimport { KeyPairBase, type Signature } from './key_pair_base.js';\nimport { PublicKey } from './public_key.js';\n\n/** ML-DSA-65 key pair for post-quantum transaction signing. */\nexport class KeyPairMLDSA65 extends KeyPairBase {\n    readonly publicKey: PublicKey;\n    readonly secretKey: string;\n\n    constructor(secretKey: string) {\n        super();\n        const secretKeyBytes = baseDecode(secretKey);\n        this.publicKey = new PublicKey({ keyType: KeyType.MLDSA65, data: ml_dsa65.getPublicKey(secretKeyBytes) });\n        this.secretKey = secretKey;\n    }\n\n    static fromRandom(): KeyPairMLDSA65 {\n        const { secretKey } = ml_dsa65.keygen();\n        return new KeyPairMLDSA65(baseEncode(secretKey));\n    }\n\n    sign(message: Uint8Array): Signature {\n        return { signature: ml_dsa65.sign(message, baseDecode(this.secretKey)), publicKey: this.publicKey };\n    }\n\n    verify(message: Uint8Array, signature: Uint8Array): boolean {\n        return this.publicKey.verify(message, signature);\n    }\n\n    toString(): KeyPairString {\n        return `ml-dsa-65:${this.secretKey}`;\n    }\n\n    getPublicKey(): PublicKey {\n        return this.publicKey;\n    }\n}\n","import { secp256k1 } from '@noble/curves/secp256k1.js';\nimport { baseDecode, baseEncode } from '../utils/index.js';\n\nimport { type KeyPairString, KeySize, KeyType } from './constants.js';\nimport { KeyPairBase, type Signature } from './key_pair_base.js';\nimport { PublicKey } from './public_key.js';\n\n/**\n * This class provides key pair functionality for secp256k1 curve:\n * generating key pairs, encoding key pairs, signing and verifying.\n * nearcore expects secp256k1 public keys to be 64 bytes at all times,\n * even when string encoded the secp256k1 library returns 65 byte keys\n * (including a 1 byte header that indicates how the pubkey was encoded).\n * We'll force the secp256k1 library to always encode uncompressed\n * keys with the corresponding 0x04 header byte, then manually\n * insert/remove that byte as needed.\n */\nexport class KeyPairSecp256k1 extends KeyPairBase {\n    readonly publicKey: PublicKey;\n    readonly secretKey: string;\n    readonly extendedSecretKey: string;\n\n    /**\n     * Construct an instance of key pair given a secret key.\n     * It's generally assumed that these are encoded in base58.\n     * @param {string} extendedSecretKey\n     */\n    constructor(extendedSecretKey: string) {\n        super();\n        const decoded = baseDecode(extendedSecretKey);\n        const secretKey = new Uint8Array(decoded.slice(0, KeySize.SECRET_KEY));\n        const withHeader = secp256k1.getPublicKey(new Uint8Array(secretKey), false);\n        const data = withHeader.subarray(1); // remove the 0x04 header byte\n        this.publicKey = new PublicKey({\n            keyType: KeyType.SECP256K1,\n            data,\n        });\n        this.secretKey = baseEncode(secretKey);\n        this.extendedSecretKey = extendedSecretKey;\n    }\n\n    /**\n     * Generate a new random keypair.\n     * @example\n     * const keyRandom = KeyPair.fromRandom();\n     * keyRandom.publicKey\n     * // returns [PUBLIC_KEY]\n     *\n     * keyRandom.secretKey\n     * // returns [SECRET_KEY]\n     */\n    static fromRandom() {\n        const secretKey = crypto.getRandomValues(new Uint8Array(KeySize.SECRET_KEY));\n        const withHeader = secp256k1.getPublicKey(secretKey, false);\n        const publicKey = withHeader.subarray(1);\n        const extendedSecretKey = new Uint8Array([...secretKey, ...publicKey]);\n        return new KeyPairSecp256k1(baseEncode(extendedSecretKey));\n    }\n\n    sign(message: Uint8Array): Signature {\n        // nearcore expects 65 byte signatures formed by appending the recovery id to the 64 byte signature\n        // noble v2 'recovered' format is [recovery, r, s] but NEAR expects [r, s, recovery]\n        // prehash: false because NEAR already provides a sha256-hashed message\n        const raw = secp256k1.sign(message, baseDecode(this.secretKey), { prehash: false, format: 'recovered' });\n        const signature = new Uint8Array(65);\n        signature.set(raw.subarray(1), 0); // r, s (64 bytes)\n        signature[64] = raw[0]!; // recovery byte\n        return { signature, publicKey: this.publicKey };\n    }\n\n    verify(message: Uint8Array, signature: Uint8Array): boolean {\n        return this.publicKey.verify(message, signature);\n    }\n\n    toString(): KeyPairString {\n        return `secp256k1:${this.extendedSecretKey}`;\n    }\n\n    getPublicKey(): PublicKey {\n        return this.publicKey;\n    }\n}\n","import type { CurveType, KeyPairString } from './constants.js';\nimport { KeyPairBase } from './key_pair_base.js';\nimport { KeyPairEd25519 } from './key_pair_ed25519.js';\nimport { KeyPairMLDSA65 } from './key_pair_ml_dsa_65.js';\nimport { KeyPairSecp256k1 } from './key_pair_secp256k1.js';\n\nexport abstract class KeyPair extends KeyPairBase {\n    /**\n     * @param curve Name of elliptical curve, case-insensitive\n     * @returns Random KeyPair based on the curve\n     */\n    static fromRandom(curve: CurveType): KeyPair {\n        switch (curve.toUpperCase()) {\n            case 'ED25519':\n                return KeyPairEd25519.fromRandom();\n            case 'SECP256K1':\n                return KeyPairSecp256k1.fromRandom();\n            case 'ML-DSA-65':\n                return KeyPairMLDSA65.fromRandom();\n            default:\n                throw new Error(`Unknown curve ${curve}`);\n        }\n    }\n\n    /**\n     * Creates a key pair from an encoded key string.\n     * @param encodedKey The encoded key string.\n     * @returns {KeyPair} The key pair created from the encoded key string.\n     */\n    static fromString(encodedKey: KeyPairString): KeyPair {\n        const parts = encodedKey.split(':');\n        if (parts.length === 2) {\n            switch (parts[0]!.toUpperCase()) {\n                case 'ED25519':\n                    return new KeyPairEd25519(parts[1]!);\n                case 'SECP256K1':\n                    return new KeyPairSecp256k1(parts[1]!);\n                case 'ML-DSA-65':\n                    return new KeyPairMLDSA65(parts[1]!);\n                default:\n                    throw new Error(`Unknown curve: ${parts[0]}`);\n            }\n        } else {\n            throw new Error('Invalid encoded key format, must be <curve>:<encoded key>');\n        }\n    }\n}\n"],"mappings":"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","names":["import_ed25519","import_ml_dsa","import_secp256k1","internalParseSeedPhrase","internalGenerateSeedPhrase"]}