@accesly/react 1.0.0-pre.0 → 1.0.0-pre.2

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Environment, CognitoConfig, AuthClient, SessionStorage, DeviceStore, TelemetrySink, TokenManager, AccesslyEndpoints, AuthStatus, CredentialRecord } from '@accesly/core';
+import { Environment, CognitoConfig, AuthClient, SessionStorage, DeviceStore, TelemetrySink, TokenManager, AccesslyEndpoints, AuthStatus, CredentialRecord, EncryptedEnvelope } from '@accesly/core';
 import * as react from 'react';
 import { ReactNode } from 'react';
 
@@ -127,6 +127,22 @@ interface CreateWalletInput {
     readonly credentialId?: Uint8Array;
     /** Optional. See `credentialId`. */
     readonly prfSalt?: Uint8Array;
+    /**
+     * Password de Cognito en plano (`Uint8Array` codificado UTF-8).
+     *
+     * Recovery v2 (Fase 1, 2026-06-15): si se provee, el SDK deriva
+     * `recoveryKey = PBKDF2(password, recoverySalt, 600k)` y la usa para
+     * cifrar F3 antes de enviarlo al backend, en vez de usar
+     * `encryptionKeys[2]`. El backend almacena F3 cifrado con esa key —
+     * SOLO descifrable client-side con el mismo password.
+     *
+     * Sin esta prop el wallet se crea pero NO podrá recuperarse vía OTP
+     * (F3 quedará cifrado con `encryptionKeys[2]`, igual que en 0.x).
+     *
+     * El caller es responsable de zeroizar este buffer tras `createWallet`
+     * (el SDK no lo retiene en memoria).
+     */
+    readonly cognitoPassword?: Uint8Array;
 }
 interface CreatedWalletInfo {
     readonly walletAddress: string;
@@ -409,11 +425,90 @@ interface YieldNamespace {
 declare class NotImplementedYetError extends Error {
     constructor(namespace: string, method: string);
 }
+/**
+ * Recovery v2 — OTP por email + password de Cognito (Fase 1, 2026-06-15).
+ *
+ * Flujo desde la UI:
+ *   1. `recovery.requestOtp({ email })` → manda el OTP por SES.
+ *   2. `recovery.verifyOtp({ email, code })` → devuelve `recoveryJwt`.
+ *   3. `recovery.finalize({ email, password, recoveryJwt })` orquesta todo:
+ *      - GET /fragments/3 con el JWT
+ *      - Deriva recoveryKey con el password + recoverySalt del backend
+ *      - Decifra F3
+ *      - Decifra F2 (vía session key ECDH)
+ *      - Combina F2+F3 → seed ed25519 reconstruida
+ *      - Genera new passkey + new Shamir split (F1', F2', F3')
+ *      - Re-cifra F3' con la misma recoveryKey + nuevo salt
+ *      - Firma la tx `rotate_signer` localmente
+ *      - POST /recovery/finalize con todo
+ *      - Persiste new CredentialRecord local
+ *      - Zero-iza la seed
+ */
+interface ReconstructedSeed {
+    /** 32-byte ed25519 seed reconstruida vía Shamir(F2_recovery + F3). CALLER ZEROIZE. */
+    readonly privateSeed: Uint8Array;
+    /** 32-byte ed25519 public key derivada. */
+    readonly publicKey: Uint8Array;
+    /** 32-byte recoveryKey derivada del password — útil para re-cifrar F2'/F3' nuevos. */
+    readonly recoveryKey: Uint8Array;
+    /** Base64 32-byte salt que vino del backend. */
+    readonly recoverySalt: string;
+}
+interface RecoveryNamespace {
+    /** Pide OTP. Backend rate-limita; el caller debe respetar `cooldownSeconds`. */
+    requestOtp(input: {
+        email: string;
+    }): Promise<{
+        cooldownSeconds: number;
+        expiresInSeconds: number;
+    }>;
+    /** Verifica OTP. Devuelve `recoveryJwt` con TTL 5min. */
+    verifyOtp(input: {
+        email: string;
+        code: string;
+    }): Promise<{
+        recoveryJwt: string;
+        expiresAt: number;
+    }>;
+    /**
+     * Descarga `/fragments/3`, descifra F2_recovery + F3 con la `recoveryKey`
+     * derivada del password y reconstruye la seed via Shamir.
+     *
+     * El caller DEBE zero-izar `result.privateSeed` y `result.recoveryKey`
+     * tras firmar la rotación + cifrar las nuevas F1'/F2'/F3'.
+     *
+     * El caller también es responsable de zeroizar `cognitoPassword` después.
+     */
+    reconstructSeed(input: {
+        cognitoPassword: Uint8Array;
+        recoveryJwt: string;
+    }): Promise<ReconstructedSeed>;
+    /**
+     * Envía la rotación al backend tras que el caller haya construido la tx
+     * `rotate_signer` y firmado el auth entry localmente.
+     */
+    submitFinalize(input: {
+        recoveryJwt: string;
+        unsignedXdr: string;
+        newSecp256r1Pubkey: string;
+        newFragmentF1Encrypted: EncryptedEnvelope;
+        newFragmentF2Encrypted: EncryptedEnvelope;
+        newFragmentF2Recovery: EncryptedEnvelope;
+        newFragmentF3Encrypted: EncryptedEnvelope;
+        newRecoverySalt: string;
+        newEmailCommitment: string;
+    }): Promise<{
+        walletAddress: string;
+        txHash: string;
+        status: string;
+    }>;
+}
 interface AcceslyHook {
     readonly auth: AuthNamespace;
     readonly wallet: WalletNamespace;
     readonly tx: TxNamespace;
     readonly kyc: KycNamespace;
+    readonly recovery: RecoveryNamespace;
     readonly session: SessionNamespace;
     readonly settings: SettingsNamespace;
     readonly yieldOps: YieldNamespace;
@@ -446,4 +541,4 @@ declare function useAccesly(): AcceslyHook;
  */
 declare const REACT_ADAPTER_VERSION = "0.0.0";
 
-export { AcceslyContext, type AcceslyContextValue, type AcceslyHook, AcceslyProvider, type AcceslyProviderProps, type AuthNamespace, type CreateWalletInput, type CreatedWalletInfo, ENVIRONMENT_DEFAULTS, type EnsureWalletResult, type EnvironmentDefaults, type KycNamespace, NotImplementedYetError, REACT_ADAPTER_VERSION, type RemoteWalletInfo, type RetryDeployResult, type SendXlmInput, type SendXlmResult, type SessionNamespace, type SettingsNamespace, type TxNamespace, type WalletNamespace, type WalletStatus, type YieldNamespace, useAccesly };
+export { AcceslyContext, type AcceslyContextValue, type AcceslyHook, AcceslyProvider, type AcceslyProviderProps, type AuthNamespace, type CreateWalletInput, type CreatedWalletInfo, ENVIRONMENT_DEFAULTS, type EnsureWalletResult, type EnvironmentDefaults, type KycNamespace, NotImplementedYetError, REACT_ADAPTER_VERSION, type RecoveryNamespace, type RemoteWalletInfo, type RetryDeployResult, type SendXlmInput, type SendXlmResult, type SessionNamespace, type SettingsNamespace, type TxNamespace, type WalletNamespace, type WalletStatus, type YieldNamespace, useAccesly };

package/dist/index.js

@@ -1,4 +1,4 @@
-import { CognitoAuthClient, InMemorySessionStorage, InMemoryDeviceStore, TokenManager, AccesslyApiClient, AccesslyEndpoints, normalizeSecp256r1Pubkey, createWallet, computeSmartAccountAddress, signTransaction, generateX25519Keypair, unwrapSessionFragment2, reconstructFromPlainAndEncrypted, signSorobanAuthEntry, AccesslyApiError } from '@accesly/core';
+import { CognitoAuthClient, InMemorySessionStorage, InMemoryDeviceStore, TokenManager, AccesslyApiClient, AccesslyEndpoints, normalizeSecp256r1Pubkey, createWallet, generateRecoverySalt, decryptAesGcm, deriveRecoveryKey, encryptAesGcm, emailHashBytes, computeSmartAccountAddress, signTransaction, generateX25519Keypair, unwrapSessionFragment2, reconstructFromPlainAndEncrypted, signSorobanAuthEntry, reconstructKey, AccesslyApiError } from '@accesly/core';
 import { createContext, useMemo, useState, useRef, useEffect, useContext } from 'react';
 import { jsx } from 'react/jsx-runtime';
 
@@ -189,7 +189,10 @@ function useAccesly() {
         emailCommitment: hexFromBytes(params.emailCommitment),
         secp256r1Pubkey: hexFromBytes(params.secp256r1Pubkey),
         fragmentF2: encodeFragmentToWire(params.fragmentF2),
-        fragmentF3: encodeFragmentToWire(params.fragmentF3)
+        fragmentF3: encodeFragmentToWire(params.fragmentF3),
+        ...params.fragmentF2Recovery ? { fragmentF2Recovery: encodeFragmentToWire(params.fragmentF2Recovery) } : {},
+        ...params.emailHash ? { emailHash: params.emailHash } : {},
+        ...params.recoverySalt ? { recoverySalt: params.recoverySalt } : {}
       });
       return res.walletAddress;
     };
@@ -270,6 +273,28 @@ function useAccesly() {
           emailSalt: input.emailSalt,
           encryptionKeys: input.encryptionKeys
         });
+        let fragmentF3ToSend = created.encryptedFragments[2];
+        let fragmentF2Recovery;
+        let recoverySaltBase64;
+        if (input.cognitoPassword) {
+          const recoverySalt = generateRecoverySalt();
+          const f2Plain = decryptAesGcm(created.encryptedFragments[1], input.encryptionKeys[1]);
+          const f3Plain = decryptAesGcm(created.encryptedFragments[2], input.encryptionKeys[2]);
+          const recoveryKey = deriveRecoveryKey({
+            password: input.cognitoPassword,
+            salt: recoverySalt
+          });
+          try {
+            fragmentF2Recovery = encryptAesGcm(f2Plain, recoveryKey);
+            fragmentF3ToSend = encryptAesGcm(f3Plain, recoveryKey);
+          } finally {
+            for (let i = 0; i < recoveryKey.length; i += 1) recoveryKey[i] = 0;
+            for (let i = 0; i < f2Plain.length; i += 1) f2Plain[i] = 0;
+            for (let i = 0; i < f3Plain.length; i += 1) f3Plain[i] = 0;
+          }
+          recoverySaltBase64 = base64FromBytes(recoverySalt);
+        }
+        const emailHashHex = hexFromBytes(emailHashBytes(input.email));
         const predictedAddress = await computeSmartAccountAddress({
           ownerPubkey: created.publicKey,
           deployerAddress: stellarConfig.deployerAddress,
@@ -283,7 +308,7 @@ function useAccesly() {
             secp256r1Pubkey: secp256r1Canonical,
             fragmentF1Encrypted: created.encryptedFragments[0],
             fragmentF2Encrypted: created.encryptedFragments[1],
-            fragmentF3Encrypted: created.encryptedFragments[2],
+            fragmentF3Encrypted: fragmentF3ToSend,
             publicKey: created.publicKey,
             emailCommitment: created.emailCommitment,
             prfSalt: input.prfSalt,
@@ -302,7 +327,10 @@ function useAccesly() {
             emailCommitment: created.emailCommitment,
             secp256r1Pubkey: secp256r1Canonical,
             fragmentF2: created.encryptedFragments[1],
-            fragmentF3: created.encryptedFragments[2]
+            fragmentF3: fragmentF3ToSend,
+            emailHash: emailHashHex,
+            ...fragmentF2Recovery ? { fragmentF2Recovery } : {},
+            ...recoverySaltBase64 ? { recoverySalt: recoverySaltBase64 } : {}
           });
         } catch (err) {
           if (!isSorobanDeployPendingError(err)) throw err;
@@ -503,6 +531,62 @@ function useAccesly() {
     }),
     [ctx]
   );
+  const recovery = useMemo(
+    () => ({
+      async requestOtp(input) {
+        return ctx.endpoints.requestRecoveryOtp(input);
+      },
+      async verifyOtp(input) {
+        return ctx.endpoints.verifyRecoveryOtp(input);
+      },
+      async reconstructSeed(input) {
+        const frag = await ctx.endpoints.getFragment3(input.recoveryJwt);
+        if (!frag.fragmentF2Recovery) {
+          throw new Error(
+            "recovery.reconstructSeed: la wallet fue creada antes de Fase 1 y no tiene F2 cipher-bound a recoveryKey. No es recuperable v\xEDa OTP."
+          );
+        }
+        const recoverySalt = base64ToBytes(frag.recoverySalt);
+        const recoveryKey = deriveRecoveryKey({
+          password: input.cognitoPassword,
+          salt: recoverySalt
+        });
+        const f2Envelope = {
+          ciphertext: base64ToBytes(frag.fragmentF2Recovery.ciphertext),
+          nonce: base64ToBytes(frag.fragmentF2Recovery.nonce)
+        };
+        const f3Envelope = {
+          ciphertext: base64ToBytes(frag.fragmentF3Encrypted.ciphertext),
+          nonce: base64ToBytes(frag.fragmentF3Encrypted.nonce)
+        };
+        const seedResult = reconstructKey({
+          fragments: [
+            { envelope: f2Envelope, key: recoveryKey },
+            { envelope: f3Envelope, key: recoveryKey }
+          ]
+        });
+        return {
+          privateSeed: seedResult.privateSeed,
+          publicKey: seedResult.publicKey,
+          recoveryKey,
+          recoverySalt: frag.recoverySalt
+        };
+      },
+      async submitFinalize(input) {
+        return ctx.endpoints.finalizeRecovery(input.recoveryJwt, {
+          unsignedXdr: input.unsignedXdr,
+          newSecp256r1Pubkey: input.newSecp256r1Pubkey,
+          newFragmentF1Encrypted: encodeFragmentToWire(input.newFragmentF1Encrypted),
+          newFragmentF2Encrypted: encodeFragmentToWire(input.newFragmentF2Encrypted),
+          newFragmentF2Recovery: encodeFragmentToWire(input.newFragmentF2Recovery),
+          newFragmentF3Encrypted: encodeFragmentToWire(input.newFragmentF3Encrypted),
+          newRecoverySalt: input.newRecoverySalt,
+          newEmailCommitment: input.newEmailCommitment
+        });
+      }
+    }),
+    [ctx]
+  );
   const session = useMemo(
     () => ({
       async create() {
@@ -545,7 +629,7 @@ function useAccesly() {
     }),
     []
   );
-  return { auth, wallet, tx, kyc, session, settings, yieldOps, _internal: ctx };
+  return { auth, wallet, tx, kyc, recovery, session, settings, yieldOps, _internal: ctx };
 }
 function coderHelpers() {
   function hexFromBytes(bytes) {