Recover Access

import type { Call } from "starknet";
import { Recover, useGuardianRecovery } from "@chipi-stack/chipi-react";
import {
  parseOpProposedEvents,
  waitForTransaction,
  type NewOwnerInput,
} from "@chipi-stack/backend";

// Your outside-execution submit path: an owner signs, the paymaster relays.
// Returns the transaction hash.
declare function submitThroughPaymaster(calls: Call[]): Promise<string>;

function AddDevice(props: {
  walletAddress: string;
  // e.g. { kind: "STARK", pubkeyBytes: [newOwnerPubkey], role: "OWNER", weight: 1, label: "laptop" }
  newOwner: NewOwnerInput;
  // The op you stored after onPropose, or null.
  pendingOp: { opId: bigint; validAfter: number } | null;
}) {
  const { walletAddress, newOwner } = props;
  const recovery = useGuardianRecovery();

  return (
    <Recover
      mode="add-device"
      walletAddress={walletAddress}
      newOwner={newOwner}
      pendingOp={props.pendingOp}
      onPropose={async () => {
        const call = recovery.buildProposeAddOwner({
          walletAddress,
          proposer: 0, // owner_id of the owner who signs
          newOwner,
        });
        const tx = await waitForTransaction(await submitThroughPaymaster([call]));
        if (!tx.success) throw new Error(tx.revertReason ?? "propose_add_owner reverted");
        const [op] = parseOpProposedEvents(tx.events, walletAddress);
        if (!op) throw new Error("No OpProposed event in the receipt");
        return { opId: op.opId, validAfter: op.validAfter };
      }}
      onExecute={async (opId) => {
        const call = recovery.buildExecuteAddOwner({ walletAddress, opId, newOwner });
        const tx = await waitForTransaction(await submitThroughPaymaster([call]));
        if (!tx.success) throw new Error(tx.revertReason ?? "execute_add_owner reverted");
      }}
    />
  );
}

import type { Call } from "starknet";
import { RpcProvider } from "starknet";
import { Recover, useGuardianRecovery } from "@chipi-stack/chipi-react";
import {
  readPendingRecovery,
  waitForTransaction,
  type NewOwnerInput,
} from "@chipi-stack/backend";

// The guardian signs an OE with exactly this one call; anyone relays it.
declare function submitGuardianSigned(calls: Call[]): Promise<string>;
// Any submit path: finalize_recovery needs no signature.
declare function submitThroughPaymaster(calls: Call[]): Promise<string>;

const provider = new RpcProvider({ nodeUrl: "https://api.cartridge.gg/x/starknet/mainnet" });

function RecoverWallet(props: {
  walletAddress: string;
  guardianOwnerId: number;
  newOwner: NewOwnerInput;
  pendingOp: { opId: bigint; validAfter: number } | null;
}) {
  const { walletAddress, guardianOwnerId, newOwner } = props;
  const recovery = useGuardianRecovery();

  return (
    <Recover
      mode="guardian-recovery"
      walletAddress={walletAddress}
      newOwner={newOwner}
      pendingOp={props.pendingOp}
      onPropose={async () => {
        const call = recovery.buildInitiateRecovery({
          walletAddress,
          proposer: guardianOwnerId, // must be the signing guardian's own owner_id
          newOwner,
        });
        const tx = await waitForTransaction(await submitGuardianSigned([call]));
        if (!tx.success) throw new Error(tx.revertReason ?? "initiate_recovery reverted");
        const pending = await readPendingRecovery(provider, walletAddress);
        // Recovery has no op_id; the component only needs a stable key for it.
        return { opId: pending.newOwnerHash, validAfter: pending.validAfter };
      }}
      onExecute={async () => {
        const call = recovery.buildFinalizeRecovery({ walletAddress, newOwner });
        const tx = await waitForTransaction(await submitThroughPaymaster([call]));
        if (!tx.success) throw new Error(tx.revertReason ?? "finalize_recovery reverted");
      }}
    />
  );
}

import { useExternalSignerExecute } from "@chipi-stack/chipi-react";
import { buildInitiateRecoveryCall, type NewOwnerInput } from "@chipi-stack/backend";

declare const bramble: { request(call: { type: string; params?: unknown }): Promise<unknown> };

export function useStartRecoveryWithBramble() {
  const { executeAsync } = useExternalSignerExecute();

  // Call from a click: Bramble opens its panel only during a user gesture.
  return (args: {
    walletAddress: string;
    guardianOwnerId: number; // Bramble's index in the owner set (readShhhOwners)
    newOwner: NewOwnerInput;
    bearerToken: string;
  }) =>
    executeAsync({
      params: {
        walletAddress: args.walletAddress,
        ownerIndex: args.guardianOwnerId,
        // Exactly one call, with proposer = the guardian's own owner id.
        calls: [
          buildInitiateRecoveryCall({
            walletAddress: args.walletAddress,
            proposer: args.guardianOwnerId,
            newOwner: args.newOwner,
          }),
        ],
        signTypedData: async (typedData) =>
          (await bramble.request({ type: "wallet_signTypedData", params: typedData })) as string[],
      },
      bearerToken: args.bearerToken,
    }); // resolves to the tx hash: wait for it before showing the countdown
}

import {
  buildProposeAddOwnerCall,
  buildProposeAddVerifierClassCall,
  readVerifierClass,
  type NewOwnerInput,
  type StarknetCallProvider,
} from "@chipi-stack/backend";

declare const provider: StarknetCallProvider;
declare const walletAddress: string;
declare const newOwner: NewOwnerInput; // kind: "WEBAUTHN_P256"

const calls = [buildProposeAddOwnerCall({ walletAddress, proposer: 0, newOwner })];
if ((await readVerifierClass(provider, walletAddress, "WEBAUTHN_P256")) === 0n) {
  calls.unshift(
    buildProposeAddVerifierClassCall({ walletAddress, proposer: 0, kind: "WEBAUTHN_P256" })
  );
}
// An owner signs one OE with `calls`.

import type { Call } from "starknet";
import { useGuardianRecovery } from "@chipi-stack/chipi-react";
import { waitForTransaction } from "@chipi-stack/backend";

declare function submitThroughPaymaster(calls: Call[]): Promise<string>;

function useCancelHandlers(walletAddress: string, signingOwnerId: number) {
  const recovery = useGuardianRecovery();
  return {
    // <Recover mode="add-device" onCancel={cancelAddDevice} />
    cancelAddDevice: async (opId: bigint | string) => {
      const call = recovery.buildCancelPendingOp({ walletAddress, opId });
      await waitForTransaction(await submitThroughPaymaster([call]));
    },
    // <Recover mode="guardian-recovery" onCancel={cancelRecovery} />
    cancelRecovery: async () => {
      const call = recovery.buildCancelRecovery({
        walletAddress,
        ownerId: signingOwnerId, // the owner signing this cancel (role OWNER), not a lost owner
      });
      await waitForTransaction(await submitThroughPaymaster([call]));
    },
  };
}

import type { ChipiServerSDK } from "@chipi-stack/backend";

declare const sdk: ChipiServerSDK;
declare const externalUserId: string;
declare const bearerToken: string;
// The same private key, re-encrypted with the new PIN or passkey-derived key.
// You produce this ciphertext: the SDK's encryption helpers are not exported
// from the package entry points.
declare const newEncryptedPrivateKey: string;

await sdk.wallets.updateWalletEncryption(
  {
    externalUserId,
    newEncryptedPrivateKey,
    // publicKey?: only needed when the user has more than one wallet
  },
  bearerToken
);