SignerAdapter

interface SignerAdapter {
  getPublicKey(): Promise<string>;
  sign(messageHash: string): Promise<SignResult>;
  getAccountAddress(): Promise<string>;
}

interface SignResult {
  r: string;
  s: string;
}

import { DirectSigner } from "@chipi-stack/core";

const signer = new DirectSigner(
  "0x1234...privateKey",
  "0xabcd...accountAddress" // optional
);

const pubKey = await signer.getPublicKey();
const sig = await signer.sign(messageHash);

new DirectSigner(privateKey: string, accountAddress?: string)

import { PasskeySigner } from "@chipi-stack/core";

// Your WebAuthn assertion function that returns a Starknet signature
async function passkeySign(challenge: string): Promise<{ r: string; s: string }> {
  // Call your WebAuthn authentication flow here
  // The challenge is the message hash to sign
  const assertion = await navigator.credentials.get({
    publicKey: { challenge: new TextEncoder().encode(challenge), /* ... */ },
  });
  // Extract r, s from the assertion response
  return { r: "0x...", s: "0x..." };
}

const signer = new PasskeySigner({
  authenticateFn: passkeySign,
  publicKey: userPasskeyPublicKey,
  accountAddress: userAccountAddress,
});

// Now use with TxBuilder via the Account
const sig = await signer.sign(messageHash);

new PasskeySigner(opts: {
  authenticateFn: (challenge: string) => Promise<{ r: string; s: string }>;
  publicKey: string;
  accountAddress: string;
})

import { ExternalSigner } from "@chipi-stack/core";

// Example: a STARK key held by your signing service (KMS, HSM or MPC).
declare const signingService: {
  publicKey(): Promise<string>;
  signHash(hash: string): Promise<{ r: string; s: string }>;
};
declare const accountAddress: string;

const signer = new ExternalSigner({
  getPublicKey: () => signingService.publicKey(),
  sign: (hash) => signingService.signHash(hash),
  getAccountAddress: async () => accountAddress,
});

import { RpcProvider, WalletAccount, type TypedData } from "starknet";

declare const typedData: TypedData; // its domain chainId must be Bramble's network ("SN_MAIN")

const bramble = (window as unknown as { starknet_bramble?: WalletAccount["walletProvider"] })
  .starknet_bramble;
if (!bramble) throw new Error("Bramble is not installed");

// From a click: sends wallet_requestAccounts with { silent_mode: false }.
const account = await WalletAccount.connect(
  new RpcProvider({ nodeUrl: "https://api.cartridge.gg/x/starknet/mainnet" }),
  bramble
);
const signature = await account.signMessage(typedData); // wallet_signTypedData, string[]

new ExternalSigner(opts: {
  getPublicKey: () => Promise<string>;
  sign: (messageHash: string) => Promise<SignResult>;
  getAccountAddress: () => Promise<string>;
})

const signer = new DirectSigner(process.env.AUTOMATION_KEY!);
// Build and sign transactions programmatically

import { ExternalSigner, PasskeySigner, type SignerAdapter } from "@chipi-stack/core";

declare const passkeyOptions: ConstructorParameters<typeof PasskeySigner>[0];
declare const kmsOptions: ConstructorParameters<typeof ExternalSigner>[0];

function getSignerForUser(user: { keyHolder: "passkey" | "kms" }): SignerAdapter {
  return user.keyHolder === "passkey"
    ? new PasskeySigner(passkeyOptions)
    : new ExternalSigner(kmsOptions);
}

const mockSigner = new ExternalSigner({
  getPublicKey: async () => "0xtest_pubkey",
  sign: async (hash) => ({ r: "0x1", s: "0x2" }),
  getAccountAddress: async () => "0xtest_account",
});

import { createAccount, DirectSigner, TxBuilder } from "@chipi-stack/core";
import { ChipiServerSDK } from "@chipi-stack/backend";

const sdk = new ChipiServerSDK({ apiPublicKey: "pk_...", apiSecretKey: "sk_..." });
const paymaster = sdk.createPaymasterAdapter();

const provider = { nodeUrl: "https://starknet-mainnet.infura.io/v3/YOUR_KEY" };
const accountAddress = "0xYOUR_ACCOUNT_ADDRESS";
const signer = new DirectSigner(process.env.PRIVATE_KEY!, accountAddress);
const account = await createAccount({ signer, provider });

const txHash = await new TxBuilder(account, { paymaster })
  .transfer(USDC, [{ to, amount }])
  .sendSponsored(); // gasless!

const provider = { nodeUrl: "https://starknet-mainnet.infura.io/v3/YOUR_KEY" };
const accountAddress = "0xYOUR_ACCOUNT_ADDRESS";
const signer = new DirectSigner(process.env.PRIVATE_KEY!, accountAddress);
const account = await createAccount({ signer, provider });

const result = await new TxBuilder(account)
  .transfer(USDC, [{ to, amount }])
  .send(); // user pays STRK for gas