Trusted wallets

StarknetDomain { name: "Shhh", version: "1", chainId: "SN_MAIN", revision: "1" }
Approval { Wallet: <the Chipi wallet>, Hash: <the transaction hash> }

import {
  resolveStarkSnip12Signer,
  starkSnip12ApprovalTypedData,
  type StarknetCallProvider,
} from "@chipi-stack/backend";

declare const bramble: { request(call: { type: string; params?: unknown }): Promise<unknown> };
declare const provider: StarknetCallProvider; // e.g. new RpcProvider({ nodeUrl })
declare const chipiWalletAddress: string;

// From a click: Bramble opens its panel only during a user gesture.
const [brambleAddress] = (await bramble.request({
  type: "wallet_requestAccounts",
  params: { silent_mode: false },
})) as string[];

// Any fresh value works: this signature only proves which key signs for Bramble.
const messageHash = BigInt(Date.now());
const typedData = starkSnip12ApprovalTypedData({ walletAddress: chipiWalletAddress, messageHash });
const signature = (await bramble.request({
  type: "wallet_signTypedData",
  params: typedData,
})) as string[];

// A new Bramble account is not deployed yet: its deployment data carries the key.
let deploymentData: { address: string; class_hash: string; salt: string; calldata: string[] } | undefined;
try {
  deploymentData = (await bramble.request({ type: "wallet_deploymentData" })) as typeof deploymentData;
} catch {
  // 115: already deployed. The key is read from the account instead.
}

const { starkPubkey, pubkeyFelts } = await resolveStarkSnip12Signer({
  provider,
  signerAddress: brambleAddress,
  walletAddress: chipiWalletAddress,
  messageHash,
  signature,
  deploymentData,
});

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

declare const provider: StarknetCallProvider & StarknetClassProvider;
declare const chipiWalletAddress: string;
declare const pubkeyFelts: bigint[];
declare const role: OwnerRole; // "OWNER" (co-owner) or "GUARDIAN" (recovery only)

if (!(await isShhhVerifierDeclared(provider, "STARK_SNIP12"))) {
  throw new Error("STARK_SNIP12 is not declared on this network yet.");
}

const proposeCalls = [];
if ((await readVerifierClass(provider, chipiWalletAddress, "STARK_SNIP12")) === 0n) {
  proposeCalls.push(
    buildProposeAddVerifierClassCall({ walletAddress: chipiWalletAddress, proposer: 0, kind: "STARK_SNIP12" })
  );
}
proposeCalls.push(
  buildProposeAddOwnerCall({
    walletAddress: chipiWalletAddress,
    proposer: 0,
    newOwner: { kind: "STARK_SNIP12", pubkeyBytes: pubkeyFelts, role, weight: 1, label: "bramble" },
  })
);

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

declare const receipt: { events: Array<{ from_address?: string; keys: string[]; data: string[] }> };
declare const chipiWalletAddress: string;

const ops = parseOpProposedEvents(receipt.events, chipiWalletAddress);
const addVerifier = ops.find((op) => op.opKind === "ADD_VERIFIER");
const addOwner = ops.find((op) => op.opKind === "ADD_OWNER");
// addOwner.validAfter is the unix time when step 3 opens.

import {
  buildExecuteAddOwnerCall,
  buildExecuteAddVerifierClassCall,
  readShhhOwners,
  type OwnerRole,
  type StarknetCallProvider,
} from "@chipi-stack/backend";

declare const provider: StarknetCallProvider;
declare const chipiWalletAddress: string;
declare const pubkeyFelts: bigint[];
declare const role: OwnerRole; // the same role as in step 2
declare const addVerifier: { opId: bigint } | undefined;
declare const addOwner: { opId: bigint };

const executeCalls = [
  ...(addVerifier
    ? [buildExecuteAddVerifierClassCall({ walletAddress: chipiWalletAddress, opId: addVerifier.opId, kind: "STARK_SNIP12" })]
    : []),
  buildExecuteAddOwnerCall({
    walletAddress: chipiWalletAddress,
    opId: addOwner.opId,
    newOwner: { kind: "STARK_SNIP12", pubkeyBytes: pubkeyFelts, role, weight: 1, label: "bramble" },
  }),
];

// After it lands, Bramble's index in the owner set is what it signs with.
const owners = await readShhhOwners(provider, chipiWalletAddress);
const brambleId = owners.find((o) => o.kind === "STARK_SNIP12" && !o.revoked)?.ownerId;

import { ChipiSDK, buildSessionSetupCalls } from "@chipi-stack/backend";

declare const sdk: ChipiSDK;
declare const bramble: { request(call: { type: string; params?: unknown }): Promise<unknown> };
declare const chipiWalletAddress: string;
declare const brambleId: number;
declare const brambleAddress: string;
declare const starkPubkey: bigint; // from step 1
declare const sessionPublicKey: string;
// bearerToken: the user's JWT, as for any Chipi call.
const USDC = "0x033068f6539f8e6e6b131e6b2b814e6c34a5224bc66947c47dab9dfee93b35fb";

const txHash = await sdk.executeWithExternalSigner({
  params: {
    walletAddress: chipiWalletAddress,
    ownerIndex: brambleId,
    calls: buildSessionSetupCalls(
      chipiWalletAddress,
      {
        sessionPublicKey,
        validUntil: Math.floor(Date.now() / 1000) + 86_400,
        maxCalls: 100,
        allowedEntrypoints: ["transfer", "approve"],
      },
      [{ token: USDC, maxPerCall: 5_000_000n, maxPerWindow: 20_000_000n, windowSeconds: 86_400 }]
    ),
    signTypedData: async (typedData) =>
      (await bramble.request({ type: "wallet_signTypedData", params: typedData })) as string[],
    // Checks the signature off-chain before relaying: a wrong account or key fails here.
    signer: { address: brambleAddress, starkPubkey },
  },
  bearerToken,
});