{"version":3,"sources":["../src/index.ts","../src/auth/sign.ts","../src/crypto/crypto.ts","../src/schemas.ts","../src/utils/nonce.ts","../src/auth/createAuthToken.ts","../src/auth/verify.ts","../src/auth/parseAuthToken.ts","../src/utils/encoding.ts"],"sourcesContent":["// --- Core API Functions ---\nexport { sign } from \"./auth/sign.js\";\nexport { verify } from \"./auth/verify.js\";\n\n// --- Helper Functions ---\nexport { parseAuthToken } from \"./auth/parseAuthToken.js\";\nexport { generateNonce } from \"./utils/nonce.js\";\n\n// --- Utility Exports ---\nexport { stringToUint8Array, uint8ArrayToString } from \"./utils/encoding.js\";\n\n// --- Core Types ---\nexport type {\n  NearAuthData,\n  SignOptions,\n  VerificationResult,\n  VerifyOptions,\n  WalletInterface,\n} from \"./types.js\";\n","import { ed25519 } from \"@noble/curves/ed25519.js\";\nimport { base58, base64 } from \"@scure/base\";\nimport {\n  ED25519_PREFIX,\n  createNEP413Payload,\n  hashPayload,\n} from \"../crypto/crypto.js\";\nimport { NearAuthData } from \"../schemas.js\";\nimport type { SignOptions, SignedPayload, WalletInterface } from \"../types.js\";\nimport { generateNonce } from \"../utils/nonce.js\";\nimport { createAuthToken } from \"./createAuthToken.js\";\n\ninterface InternalSignParameters {\n  message: string;\n  recipient: string;\n  nonce: Uint8Array; // Actual nonce bytes\n  callbackUrl?: string | null;\n  state?: string | null;\n}\n\nasync function _signWithKeyPair(\n  keyPair: string,\n  signerId: string,\n  params: InternalSignParameters,\n): Promise<string> {\n  const { message, recipient, nonce, callbackUrl } = params;\n\n  const payload: SignedPayload = {\n    message: message,\n    nonce: Array.from(nonce),\n    recipient: recipient,\n    callbackUrl: callbackUrl || null,\n  };\n\n  const dataToHash = createNEP413Payload(payload);\n\n  const payloadHash = hashPayload(dataToHash);\n\n  if (!keyPair.startsWith(ED25519_PREFIX)) {\n    throw new Error(\"Invalid KeyPair format: missing ed25519 prefix.\");\n  }\n  const privateKeyBase58 = keyPair.substring(ED25519_PREFIX.length);\n  const privateKeyBytes = base58.decode(privateKeyBase58);\n\n  if (privateKeyBytes.length !== 64) {\n    throw new Error(\n      `Expected decoded private key to be 64 bytes for Ed25519, got ${privateKeyBytes.length}`,\n    );\n  }\n  const seed = privateKeyBytes.slice(0, 32); // Extract the 32-byte seed\n\n  const signedResult = ed25519.sign(payloadHash, seed);\n\n  const actualSignatureB64 = base64.encode(signedResult);\n\n  const publicKeyBytes = ed25519.getPublicKey(seed);\n  const publicKeyString = ED25519_PREFIX + base58.encode(publicKeyBytes);\n\n  const nearAuthDataObject: NearAuthData = {\n    accountId: signerId,\n    publicKey: publicKeyString,\n    signature: actualSignatureB64,\n    message: message,\n    nonce: Array.from(nonce),\n    recipient: recipient,\n    callbackUrl: callbackUrl || null,\n    state: params.state || null,\n  };\n\n  return createAuthToken(nearAuthDataObject);\n}\n\nasync function _signWithWallet(\n  wallet: WalletInterface,\n  params: InternalSignParameters,\n): Promise<string> {\n  const { message, recipient, nonce, callbackUrl } = params;\n\n  const walletResult = await wallet.signMessage({\n    message,\n    nonce,\n    recipient,\n  });\n\n  const nearAuthDataObject: NearAuthData = {\n    accountId: walletResult.accountId,\n    publicKey: walletResult.publicKey, // full \"ed25519:<base58_pk>\" string\n    signature: walletResult.signature,\n    message: message,\n    nonce: Array.from(nonce),\n    recipient: recipient,\n    callbackUrl: callbackUrl || null,\n    state: walletResult.state || null,\n  };\n\n  return createAuthToken(nearAuthDataObject);\n}\n\nfunction detectSignerType(\n  signer: string | WalletInterface,\n): \"keypair\" | \"wallet\" {\n  if (typeof (signer as WalletInterface).signMessage === \"function\") {\n    return \"wallet\";\n  }\n  if (typeof signer === \"string\" && signer.startsWith(ED25519_PREFIX)) {\n    return \"keypair\";\n  }\n  throw new Error(\n    \"Invalid signer: must be KeyPair or a wallet object with a signMessage method.\",\n  );\n}\n\n/**\n * Signs a message using either a KeyPair or a wallet, creating a structured\n * message and producing a NEAR authentication token.\n *\n * @param message The message to sign, can be application specific data.\n * @param options The signing options.\n * @returns A promise that resolves to the final AuthToken string.\n */\nexport async function sign(\n  message: string,\n  options: SignOptions,\n): Promise<string> {\n  const { signer, accountId, recipient, callbackUrl, nonce, state } = options;\n\n  const currentNonce = nonce || generateNonce();\n\n  const internalParams: InternalSignParameters = {\n    message: message,\n    recipient: recipient,\n    nonce: currentNonce,\n    callbackUrl: callbackUrl || null,\n    state: state || null,\n  };\n\n  const signerType = detectSignerType(signer);\n\n  if (signerType === \"keypair\") {\n    if (!accountId) {\n      throw new Error(\"accountId is required when using a KeyPair signer.\");\n    }\n    return _signWithKeyPair(signer as string, accountId, internalParams);\n  }\n\n  // For wallet, accountId comes from the wallet's response, not from options.\n  return _signWithWallet(signer as WalletInterface, internalParams);\n}\n","import { ed25519 } from \"@noble/curves/ed25519.js\";\nimport { sha256 } from \"@noble/hashes/sha2.js\";\nimport { base58 } from \"@scure/base\";\nimport { b } from \"@zorsh/zorsh\";\nimport { SignedPayloadSchema } from \"../schemas.js\";\nimport type { SignedPayload } from \"../types.js\";\n\nexport const ED25519_PREFIX = \"ed25519:\";\nexport const TAG = 2147484061;\n\n/**\n * Create a NEP-413 payload to be hashed\n * (Serialize the TAG and the payload separately, then concatenate)\n * @param payload Payload to serialize\n * @returns Concatenated, serialized payloads as Uint8Array\n */\nexport function createNEP413Payload(payload: SignedPayload): Uint8Array {\n  const serializedTag = b.u32().serialize(TAG);\n\n  const serializablePayload = {\n    // Convert nonce from Uint8Array to number[] for zorsh\n    ...payload,\n    nonce: Array.from(payload.nonce),\n    callbackUrl: payload.callbackUrl || null,\n  };\n  const serializedPayload = SignedPayloadSchema.serialize(serializablePayload);\n\n  const dataToHash = new Uint8Array(\n    serializedTag.length + serializedPayload.length,\n  );\n  dataToHash.set(serializedTag, 0);\n  dataToHash.set(serializedPayload, serializedTag.length);\n\n  return dataToHash;\n}\n\n/**\n * Hash a payload using SHA-256\n * @param payload Payload to hash\n * @returns Hashed payload as Uint8Array\n */\nexport function hashPayload(payload: Uint8Array): Uint8Array {\n  return sha256(payload);\n}\n\n/**\n * Verify a signature against a pre-computed payload hash.\n * Throws an error if verification fails or encounters an issue.\n * @param payloadHash The hash of the payload that was signed.\n * @param signatureBytes The raw signature bytes to verify.\n * @param publicKeyString The public key string (e.g., \"ed25519:...\") to verify against.\n */\nexport async function verifySignature( // remove async, update tests\n  payloadHash: Uint8Array,\n  signatureBytes: Uint8Array,\n  publicKeyString: string,\n): Promise<boolean> {\n  if (publicKeyString.startsWith(ED25519_PREFIX)) {\n    const isValid = ed25519.verify(\n      signatureBytes,\n      payloadHash,\n      base58.decode(publicKeyString.split(\":\")[1]),\n    );\n    if (!isValid) {\n      throw new Error(\"Ed25519 signature verification failed.\");\n    }\n    return true;\n  }\n\n  throw new Error(\n    `Unsupported public key type: \"${publicKeyString}\". Must start with \"${ED25519_PREFIX}\".`,\n  );\n}\n","import { b } from \"@zorsh/zorsh\";\n\n/**\n * Zorsh schema for SignedPayload (what gets hashed and signed)\n */\nexport const SignedPayloadSchema = b.struct({\n  message: b.string(),\n  nonce: b.array(b.u8(), 32), // Represents [u8; 32]\n  recipient: b.string(),\n  callbackUrl: b.option(b.string()), // Optional field\n});\n\n/**\n * Zorsh schema for NearAuthData (the full auth token data)\n * Note: zorsh uses number[] for arrays, but our API uses Uint8Array\n */\nexport const NearAuthDataSchema = b.struct({\n  accountId: b.string(),\n  publicKey: b.string(),\n  signature: b.string(),\n  message: b.string(),\n  nonce: b.array(b.u8(), 32),\n  recipient: b.string(),\n  callbackUrl: b.option(b.string()),\n  state: b.option(b.string()),\n});\n\n/**\n * TypeScript types inferred from zorsh schemas\n */\nexport type SignedPayload = b.infer<typeof SignedPayloadSchema>;\nexport type NearAuthData = b.infer<typeof NearAuthDataSchema>;\n","/**\n * Default max age for nonce validation (24 hours in milliseconds)\n */\n\nconst DEFAULT_MAX_AGE = 24 * 60 * 60 * 1000;\n\n/**\n * Generate a timestamp-based nonce\n * @returns A 32-byte Uint8Array containing the padded timestamp\n */\nexport function generateNonce(): Uint8Array {\n  const timestamp = Date.now().toString();\n  const randomBytes = crypto.getRandomValues(new Uint8Array(16));\n  const encoder = new TextEncoder();\n  const nonceArray = new Uint8Array(32);\n\n  // First 16 bytes: padded timestamp\n  const timestampBytes = encoder.encode(timestamp.padStart(16, \"0\"));\n  nonceArray.set(timestampBytes.slice(0, 16));\n\n  // Last 16 bytes: random data for uniqueness\n  nonceArray.set(randomBytes, 16);\n\n  return nonceArray;\n}\n\n/**\n * Validate a nonce\n * @param nonce Nonce as Uint8Array\n * @param maxAge Maximum age of nonce in milliseconds (defaults to 24 hours)\n * @throws Error if nonce is invalid\n */\nexport function validateNonce(\n  nonce: Uint8Array,\n  maxAge: number = DEFAULT_MAX_AGE,\n): void {\n  try {\n    // Check nonce length\n    if (nonce.length !== 32) {\n      throw new Error(\"Invalid nonce length\");\n    }\n\n    // Extract timestamp from first 16 bytes of nonce\n    const decoder = new TextDecoder();\n    const timestampBytes = nonce.slice(0, 16);\n    const timestampStr = decoder.decode(timestampBytes).replace(/^0+/, \"\");\n    const timestamp = parseInt(timestampStr, 10);\n\n    if (isNaN(timestamp)) {\n      throw new Error(\"Invalid timestamp in nonce\");\n    }\n\n    // Check if nonce is expired or from the future\n    const age = Date.now() - timestamp;\n    if (age < 0) {\n      throw new Error(\"Nonce timestamp is in the future\");\n    }\n    if (age > maxAge) {\n      throw new Error(\"Nonce has expired\");\n    }\n  } catch (error) {\n    if (error instanceof Error) {\n      throw error;\n    }\n    throw new Error(\"Unknown error validating nonce\");\n  }\n}\n","import { base64 } from \"@scure/base\";\nimport type { NearAuthData } from \"../schemas.js\";\nimport { NearAuthDataSchema } from \"../schemas.js\";\n\n/**\n * Create properly formatted auth token for API authentication\n * @param authData NEAR authentication data\n * @returns Auth token string (Base64 encoded Zorsh serialized data)\n */\nexport function createAuthToken(authData: NearAuthData): string {\n  const serialized = NearAuthDataSchema.serialize(authData);\n  return base64.encode(serialized);\n}\n","import { base64 } from \"@scure/base\";\nimport {\n  createNEP413Payload,\n  hashPayload,\n  verifySignature,\n} from \"../crypto/crypto.js\";\nimport type {\n  NearAuthData,\n  SignedPayload,\n  VerificationResult,\n  VerifyOptions,\n} from \"../types.js\";\nimport { validateNonce } from \"../utils/nonce.js\";\nimport { parseAuthToken } from \"./parseAuthToken.js\";\n\nasync function verifyPublicKeyOwner(\n  accountId: string,\n  publicKey: string,\n  requireFullAccessKey: boolean,\n): Promise<{ success: boolean; apiFailure?: boolean }> {\n  const isTestnet = accountId.endsWith(\".testnet\");\n  const baseUrl = isTestnet\n    ? \"https://test.api.fastnear.com\"\n    : \"https://api.fastnear.com\";\n  const pathSuffix = requireFullAccessKey ? \"\" : \"/all\";\n  const url = `${baseUrl}/v0/public_key/${publicKey}${pathSuffix}`;\n\n  try {\n    const response = await fetch(url);\n    if (!response.ok) {\n      return { success: false, apiFailure: true };\n    }\n    const data = await response.json();\n    if (data && Array.isArray(data.account_ids)) {\n      if (data.account_ids.includes(accountId)) {\n        return { success: true };\n      }\n      return { success: false, apiFailure: false }; // API success, but accountId not found\n    }\n    return { success: false, apiFailure: true }; // Unexpected API response format\n  } catch (error) {\n    return { success: false, apiFailure: true }; // Network error or JSON parsing error\n  }\n}\n\n/**\n * Verifies a NEAR authentication token string.\n * This includes parsing the token, validating the message structure,\n * checking nonce, public key ownership, and the cryptographic signature.\n * Throws an error if verification fails at any step.\n * @param authTokenString The Base64 encoded, Borsh-serialized NearAuthData string.\n * @param options Optional verification parameters.\n * @returns A promise that resolves to VerificationResult if successful.\n */\nexport async function verify(\n  authTokenString: string,\n  options?: VerifyOptions,\n): Promise<VerificationResult> {\n  let authData: NearAuthData;\n  try {\n    authData = parseAuthToken(authTokenString);\n  } catch (e: any) {\n    throw new Error(`Failed to parse auth token: ${e.message}`);\n  }\n\n  const {\n    accountId,\n    publicKey,\n    signature: signatureB64,\n    message: messageString,\n    nonce: nonceFromAuthData, // nonce from NearAuthData as number[]\n    recipient: recipientFromAuthData,\n    callbackUrl,\n    state,\n  } = authData;\n\n  // Convert number[] back to Uint8Array\n  const nonce = new Uint8Array(nonceFromAuthData);\n\n  // Validate nonce\n  if (options?.validateNonce) {\n    // For custom validation, pass the nonce as the original type\n    if (!options.validateNonce(nonce)) {\n      throw new Error(\"Custom nonce validation failed.\");\n    }\n  } else {\n    // Standard nonce validation using nonce from AuthData (which was part of the signed payload)\n    try {\n      validateNonce(nonce, options?.nonceMaxAge);\n    } catch (error) {\n      throw new Error(\n        `Nonce validation failed: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n  }\n\n  // Validate recipient\n  if (options?.validateRecipient) {\n    if (!options.validateRecipient(recipientFromAuthData)) {\n      throw new Error(\"Custom recipient validation failed.\");\n    }\n  } else if (options && typeof options.expectedRecipient === \"string\") {\n    if (recipientFromAuthData !== options.expectedRecipient) {\n      throw new Error(\n        `Recipient mismatch: expected '${options.expectedRecipient}', but recipient is '${recipientFromAuthData}'.`,\n      );\n    }\n  }\n\n  // Validate state\n  if (options?.validateState) {\n    if (!options.validateState(state!)) {\n      throw new Error(\"Custom state validation failed.\");\n    }\n  } else if (options && typeof options.expectedState === \"string\") {\n    if (state !== options.expectedState) {\n      throw new Error(\n        `State mismatch: expected '${options.expectedState}', got '${state?.toString() || \"undefined\"}'.`,\n      );\n    }\n  }\n\n  // Validate message\n  if (options?.validateMessage) {\n    if (!options.validateMessage(messageString)) {\n      throw new Error(\"Custom message validation failed.\");\n    }\n  } else if (options && typeof options.expectedMessage === \"string\") {\n    if (messageString !== options.expectedMessage) {\n      throw new Error(\n        `Message mismatch: expected '${options.expectedMessage}', got '${messageString}'.`,\n      );\n    }\n  }\n\n  // Validate publicKey\n  const requireFullAccessKey = options?.requireFullAccessKey ?? true;\n  const ownerCheckResult = await verifyPublicKeyOwner(\n    accountId,\n    publicKey,\n    requireFullAccessKey,\n  );\n\n  if (!ownerCheckResult.success) {\n    const reason = ownerCheckResult.apiFailure\n      ? \"API error or unexpected response\"\n      : \"public key not associated with the account or does not meet access key requirements\";\n    throw new Error(`Public key ownership verification failed: ${reason}.`);\n  }\n\n  // Reconstruct the payload that was originally signed\n  const nep413PayloadToVerify: SignedPayload = {\n    message: messageString,\n    nonce: Array.from(nonce),\n    recipient: recipientFromAuthData,\n    callbackUrl,\n  };\n\n  const dataThatWasHashed = createNEP413Payload(nep413PayloadToVerify);\n\n  const payloadHash = hashPayload(dataThatWasHashed);\n  const signatureBytes = base64.decode(signatureB64);\n\n  try {\n    // TODO: remove await, update tests\n    await verifySignature(payloadHash, signatureBytes, publicKey);\n  } catch (error) {\n    throw new Error(\n      `Cryptographic signature verification failed: ${\n        error instanceof Error ? error.message : String(error)\n      }`,\n    );\n  }\n\n  return {\n    accountId: accountId,\n    message: messageString,\n    publicKey: publicKey,\n    callbackUrl: callbackUrl || undefined,\n    state: state || undefined,\n  };\n}\n","import { base64 } from \"@scure/base\";\nimport type { NearAuthData } from \"../schemas.js\";\nimport { NearAuthDataSchema } from \"../schemas.js\";\n\n/**\n * Parse a NEAR auth token into NearAuthData\n * @param authToken The authorization token string (Base64 encoded Zorsh serialized data)\n * @returns NearAuthData\n * @throws Error if the token is invalid or missing required fields\n */\nexport function parseAuthToken(authToken: string): NearAuthData {\n  try {\n    const serialized = base64.decode(authToken);\n    const deserialized = NearAuthDataSchema.deserialize(serialized);\n\n    if (!deserialized) {\n      throw new Error(\"Deserialization failed: null result\");\n    }\n\n    return deserialized;\n  } catch (error) {\n    if (error instanceof Error) {\n      throw new Error(\n        `Invalid auth token: ${error.message.replace(/^Error: /, \"\")}`,\n      );\n    }\n    throw new Error(`Invalid auth token: ${String(error)}`);\n  }\n}\n","/**\n * Convert a string to Uint8Array\n * @param str String to convert\n * @returns Uint8Array\n */\nexport function stringToUint8Array(str: string): Uint8Array {\n  return new TextEncoder().encode(str);\n}\n\n/**\n * Convert Uint8Array to string\n * @param arr Uint8Array to convert\n * @returns String\n */\nexport function uint8ArrayToString(arr: Uint8Array): string {\n  return new TextDecoder().decode(arr);\n}\n"],"mappings":"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","names":["index_exports","__export","generateNonce","parseAuthToken","sign","stringToUint8Array","uint8ArrayToString","verify","__toCommonJS","import_ed25519","import_base","import_ed25519","import_sha2","import_base","import_zorsh","import_zorsh","SignedPayloadSchema","NearAuthDataSchema","ED25519_PREFIX","TAG","createNEP413Payload","payload","serializedTag","serializablePayload","serializedPayload","SignedPayloadSchema","dataToHash","hashPayload","verifySignature","payloadHash","signatureBytes","publicKeyString","generateNonce","timestamp","randomBytes","encoder","nonceArray","timestampBytes","validateNonce","nonce","maxAge","decoder","timestampStr","age","error","import_base","createAuthToken","authData","serialized","NearAuthDataSchema","_signWithKeyPair","keyPair","signerId","params","message","recipient","nonce","callbackUrl","payload","dataToHash","createNEP413Payload","payloadHash","hashPayload","ED25519_PREFIX","privateKeyBase58","privateKeyBytes","seed","signedResult","actualSignatureB64","publicKeyBytes","publicKeyString","nearAuthDataObject","createAuthToken","_signWithWallet","wallet","walletResult","detectSignerType","signer","sign","options","accountId","state","currentNonce","generateNonce","internalParams","import_base","import_base","parseAuthToken","authToken","serialized","deserialized","NearAuthDataSchema","error","verifyPublicKeyOwner","accountId","publicKey","requireFullAccessKey","url","response","data","verify","authTokenString","options","authData","parseAuthToken","e","signatureB64","messageString","nonceFromAuthData","recipientFromAuthData","callbackUrl","state","nonce","validateNonce","error","ownerCheckResult","reason","nep413PayloadToVerify","dataThatWasHashed","createNEP413Payload","payloadHash","hashPayload","signatureBytes","verifySignature","stringToUint8Array","str","uint8ArrayToString","arr"]}