@cavos/kit 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,244 +1,8 @@
-import { Account, Signer, ArraySignatureType } from 'starknet';
-import { D as DevicePublicKey, S as StarknetNetwork, a as DeviceSigner, C as ChainCall, b as DeviceSignature, c as ChainAdapter, d as ComputeAddressParams } from './constants-C530TZFF.js';
-export { e as DEVICE_ACCOUNT_CLASS_HASH, f as STARKNET_NETWORKS, U as UDC_ADDRESS } from './constants-C530TZFF.js';
-
-/**
- * Identity for a Cavos wallet. Login (email / social / OTP) only ever produces a
- * stable `userId`; that's all the wallet needs to derive its address. Auth never
- * touches signing — the device key does that, silently.
- *
- * Privy-style UX: the user "logs in" and the wallet is provisioned behind the
- * scenes (device key + auto-deployed smart account). The app never handles keys.
- */
-interface Identity {
-    /** Stable, backend-managed user identifier. */
-    userId: string;
-    /** Optional metadata (email, provider) for display only. */
-    email?: string;
-    provider?: "google" | "apple" | "email" | "otp" | string;
-}
-/**
- * Authenticates a user and returns their stable identity. Implementations:
- * - `CavosAuth` (hosted, mirrors `@cavos/react`: Google/Apple/email/OTP via the
- *   Cavos backend) — the default, Privy-like experience.
- * - any custom provider (the app already authenticated the user elsewhere).
- */
-interface AuthProvider {
-    authenticate(): Promise<Identity>;
-}
-/** Trivial provider when the app already has the user's stable id. */
-declare class StaticIdentity implements AuthProvider {
-    private readonly identity;
-    constructor(identity: Identity);
-    authenticate(): Promise<Identity>;
-}
-
-/**
- * Off-chain map of `user_id -> wallet`. Because the account address is
- * `f(identity, first_device_pubkey)` (unforgeable, secure), it is NOT derivable
- * from the identity alone on a new device. The backend is the source of truth
- * for "does this user already have a wallet?" — enabling multi-device:
- *
- *   - First device, unknown user  -> deploy a new wallet, then `register`.
- *   - Same user, new device        -> `lookup` returns the existing wallet; the
- *                                      new device is added as a signer (recovery
- *                                      approval), NOT a new wallet.
- *
- * The backend implements this (it already manages the user<->address binding).
- */
-interface WalletRegistry {
-    /** The user's existing wallet, or null if they don't have one yet. */
-    lookup(userId: string): Promise<RegisteredWallet | null>;
-    /** Record a freshly deployed wallet for the user (first device). */
-    register(params: {
-        userId: string;
-        address: string;
-        initialSigner: DevicePublicKey;
-    }): Promise<void>;
-    /** Note an additional device signer for the user's wallet (after approval). */
-    addDevice?(params: {
-        userId: string;
-        address: string;
-        signer: DevicePublicKey;
-    }): Promise<void>;
-}
-interface RegisteredWallet {
-    address: string;
-    /** Public keys of the devices registered on this wallet (if tracked). */
-    devices?: DevicePublicKey[];
-}
-/** Simple in-memory registry for demos / tests. */
-declare class InMemoryWalletRegistry implements WalletRegistry {
-    private wallets;
-    lookup(userId: string): Promise<RegisteredWallet | null>;
-    register(params: {
-        userId: string;
-        address: string;
-        initialSigner: DevicePublicKey;
-    }): Promise<void>;
-    addDevice(params: {
-        userId: string;
-        address: string;
-        signer: DevicePublicKey;
-    }): Promise<void>;
-}
-
-/**
- * Multi-device / recovery flow (roadmap §1.2). A new device requests addition;
- * the backend emails an approval prompt styled as a login request; the user
- * approves on an ALREADY-registered device, which signs `add_signer` for the
- * new pubkey. There is no legacy JWT path — recovery is purely device-signer
- * based.
- *
- * The backend lives outside this repo; this is the client contract the kit
- * speaks to. Provide an implementation (HTTP, etc.) when wiring an app.
- */
-interface RecoveryClient {
-    /**
-     * Step 1 (new device): request that this pubkey be added to the user's
-     * account. Triggers the approval email. Returns a request id to poll.
-     */
-    requestDeviceAddition(params: {
-        userId: string;
-        accountAddress: string;
-        newSigner: DevicePublicKey;
-        /** Owner email to send the approval link to (the SDK has it from login). */
-        email?: string;
-        /** Optional device label (browser/UA) shown in the approval email. */
-        deviceLabel?: string;
-    }): Promise<{
-        requestId: string;
-    }>;
-    /**
-     * Step 3-4 (existing device): fetch a pending addition request so the
-     * registered device can approve it by signing `add_signer`.
-     */
-    getPendingRequest(requestId: string): Promise<PendingDeviceRequest | null>;
-    /** Mark a request approved after the `add_signer` tx is submitted. */
-    confirmDeviceAddition(params: {
-        requestId: string;
-        txHash: string;
-    }): Promise<void>;
-}
-interface PendingDeviceRequest {
-    requestId: string;
-    appId?: string;
-    userId: string;
-    accountAddress: string;
-    newSigner: DevicePublicKey;
-    createdAt: string;
-    status: "pending" | "approved" | "expired";
-}
-
-interface ConnectOptions {
-    network: StarknetNetwork;
-    /** Authenticated user (pass `identity` directly, or an `auth` provider). */
-    auth?: AuthProvider;
-    identity?: Identity;
-    appSalt: string;
-    /**
-     * Cavos App ID. When set (with `backendUrl`), the kit uses the hosted
-     * WalletRegistry + RecoveryClient by default for real multi-device support.
-     */
-    appId?: string;
-    /** Cavos backend base URL. Defaults to https://cavos.xyz. */
-    backendUrl?: string;
-    /**
-     * Off-chain user_id -> wallet map. Defaults to the hosted HttpWalletRegistry
-     * when `appId` is set, else an in-memory registry (single-device only).
-     */
-    registry?: WalletRegistry;
-    /**
-     * Device-approval relay. Defaults to HttpRecoveryClient when `appId` is set;
-     * used to request addition of this device when it isn't an authorized signer.
-     */
-    recovery?: RecoveryClient;
-    /** Cavos paymaster API key (sponsors deploy + execute). */
-    paymasterApiKey: string;
-    paymasterUrl?: string;
-    rpcUrl?: string;
-    classHash?: string;
-    /** Override the device signer factory (native / tests); default WebCrypto. */
-    createSigner?: (keyId: string) => Promise<DeviceSigner>;
-}
-/** Whether this device can already operate the wallet, or needs to be added. */
-type ConnectStatus = "ready" | "needs-device-approval";
-/** Options for recovering an account after losing every device signer. */
-interface RecoveryOptions {
-    /** The recovery code the user stored when they ran setupRecovery. */
-    code: string;
-    /** Authenticated identity (same user who owns the account). */
-    identity: Identity;
-    network: StarknetNetwork;
-    appSalt: string;
-    paymasterApiKey: string;
-    appId?: string;
-    backendUrl?: string;
-    rpcUrl?: string;
-    paymasterUrl?: string;
-    classHash?: string;
-    /** Off-chain user_id -> wallet map. Defaults to the hosted registry. */
-    registry?: WalletRegistry;
-    /** Override the new device's signer (native / tests); default WebCrypto. */
-    createSigner?: (keyId: string) => Promise<DeviceSigner>;
-}
-/**
- * High-level Cavos wallet. One call logs the user in and returns a ready, gas-
- * sponsored smart account controlled by a silent device key.
- *
- *   const cavos = await Cavos.connect({ network, identity, appSalt, registry, paymasterApiKey });
- *   if (cavos.status === "ready") await cavos.execute(calls);
- *
- * The account address is `f(identity, device_pubkey)` — unforgeable, so it can't
- * be hijacked. The `registry` recognizes returning users across devices: a new
- * device on an existing account is flagged `needs-device-approval` (add it via
- * an already-registered device) instead of creating a second wallet.
- */
-declare class Cavos {
-    readonly identity: Identity;
-    readonly address: string;
-    readonly status: ConnectStatus;
-    readonly account: Account;
-    private readonly adapter;
-    private readonly devicePubkey;
-    /** Request id of the pending device-addition, when status is needs-device-approval. */
-    pendingRequestId: string | null;
-    private constructor();
-    static connect(opts: ConnectOptions): Promise<Cavos>;
-    /** This device's public key (e.g. to request addition to an existing wallet). */
-    get publicKey(): DevicePublicKey;
-    /** Execute a sponsored (gasless) multicall, signed silently by the device. */
-    execute(calls: ChainCall[]): Promise<{
-        transactionHash: string;
-    }>;
-    /** Authorize an additional device signer (sponsored). Self-submitted. */
-    addSigner(pubkey: DevicePublicKey): Promise<{
-        transactionHash: string;
-    }>;
-    /**
-     * Register a self-custodial backup signer derived from `code`, so the account
-     * can be recovered after the user loses every device. Idempotent: if the
-     * derived backup key is already an authorised signer, this is a no-op.
-     *
-     * The code never leaves the device — only its deterministic public key is
-     * added on-chain as an ordinary signer. Sponsor this like any other
-     * add_signer (gasless). Returns the transaction hash (or undefined when the
-     * backup was already set up).
-     */
-    setupRecovery(code: string): Promise<{
-        transactionHash: string;
-    } | undefined>;
-    /**
-     * Recover an account after losing every device signer. Derives the backup key
-     * from `code`, uses it (not the new device key) to sign an `add_signer` for
-     * the new device, and returns a ready Cavos bound to the new device. The
-     * account address is unchanged.
-     *
-     * Self-custodial: only someone holding the code (i.e. the rightful owner) can
-     * re-derive the backup key. The backend never sees the code.
-     */
-    static recover(opts: RecoveryOptions): Promise<Cavos>;
-}
+import { A as AuthProvider, I as Identity, W as WalletRegistry, R as RegisteredWallet, D as DevicePublicKey, a as RecoveryClient, P as PendingDeviceRequest, b as DeviceSigner, c as DeviceSignature, C as ChainAdapter, d as ComputeAddressParams, e as ChainCall, f as PasskeyAssertion, S as StellarNetwork } from './Cavos-BH2_tOQ2.js';
+export { g as Cavos, h as CavosSolana, i as CavosStellar, j as CavosWallet, k as Chain, l as ConnectOptions, m as ConnectSolanaOptions, n as ConnectStatus, o as ConnectStellarOptions, p as DEVICE_ACCOUNT_PROGRAM_ID, q as DEVICE_ACCOUNT_WASM_HASH, E as EnrolledPasskey, F as FACTORY_CONTRACT_ID, r as InMemoryWalletRegistry, s as InstructionAccount, t as InstructionData, N as NATIVE_SAC_ID, u as NetworkEnv, v as PasskeyApprovable, w as PasskeyEnrollParams, x as PasskeySigner, y as PasskeySignerOptions, z as RecoverSolanaOptions, B as RecoverStellarOptions, G as RecoveryOptions, H as SECP256R1_PROGRAM_ID, J as SOLANA_NETWORKS, K as STELLAR_NETWORKS, L as SolanaAdapter, M as SolanaAdapterOptions, O as SolanaNetwork, Q as SolanaRelayer, T as SolanaRelayerOptions, U as StaticIdentity, V as StellarRelayer, X as StellarRelayerOptions, Y as anchorDiscriminator, Z as approveDeviceEverywhere, _ as base64urlEncode, $ as batchChallenge, a0 as buildSecp256r1Instruction, a1 as compressedPubkey, a2 as encodeLowSSignature, a3 as lowS, a4 as recoverCandidatePublicKeys, a5 as serializeInstructions, a6 as webauthnDigest } from './Cavos-BH2_tOQ2.js';
+import { Signer, ArraySignatureType } from 'starknet';
+import { rpc, xdr } from '@stellar/stellar-sdk';
+import '@solana/web3.js';
 
 interface CavosAuthOptions {
     /** Cavos backend base URL. Defaults to the hosted service (same as @cavos/react). */
@@ -320,6 +84,21 @@ interface IdentityInput {
 }
 /** Derive the felt `address_seed` passed to the contract constructor. */
 declare function deriveAddressSeed({ userId, appSalt }: IdentityInput): bigint;
+/**
+ * Solana variant: a 32-byte `address_seed` for the Cavos device-account PDA.
+ * Uses the SAME identity input as Starknet (`userId + appSalt`) but hashes with
+ * SHA-256 instead of Poseidon, since Solana has no native Poseidon and the PDA
+ * seed is raw bytes. The same user therefore maps to a stable, app-scoped
+ * address on each chain (different address spaces, one identity).
+ */
+declare function deriveAddressSeedSolana({ userId, appSalt }: IdentityInput): Uint8Array;
+/**
+ * Stellar variant: a 32-byte `address_seed` used as the Soroban account's seed
+ * and folded (with the initial device signer) into the factory deploy salt.
+ * Same identity input as the other chains, SHA-256 hashed, with a Stellar-scoped
+ * domain so the same user maps to a distinct address per chain.
+ */
+declare function deriveAddressSeedStellar({ userId, appSalt }: IdentityInput): Uint8Array;
 
 interface HttpWalletRegistryOptions {
     /** Cavos backend base URL (e.g. https://cavos.xyz). */
@@ -478,6 +257,18 @@ declare class StarknetAdapter implements ChainAdapter {
     buildRemoveSigner(accountAddress: string, signer: DevicePublicKey): ChainCall;
     isAuthorizedSigner(accountAddress: string, signer: DevicePublicKey): Promise<boolean>;
     buildSignature(txHash: bigint): Promise<string[]>;
+    buildAddApprover(accountAddress: string, passkey: DevicePublicKey): ChainCall;
+    buildRemoveApprover(accountAddress: string, passkey: DevicePublicKey): ChainCall;
+    isApprover(accountAddress: string, passkey: DevicePublicKey): Promise<boolean>;
+    getPasskeyNonce(accountAddress: string): Promise<bigint>;
+    /** This chain's leaf for approving `add_signer(newSigner)` at `nonce`:
+     * `sha256(new_x || new_y || nonce)` (coords 32B BE, nonce 16B BE). The batch
+     * challenge the passkey signs is `sha256(concat(leaves))` across chains. */
+    passkeyLeaf(newSigner: DevicePublicKey, nonce: bigint): Uint8Array;
+    /** Passkey-authorized `add_signer` call. `leaves`/`leafIndex` place this chain's
+     * leaf in the multi-chain batch (single chain → `[leaf]`, index 0). `yParity`
+     * matches the raw `(r, s)` — the contract normalizes high-S internally. */
+    buildAddSignerViaPasskey(accountAddress: string, newSigner: DevicePublicKey, nonce: bigint, leaves: Uint8Array[], leafIndex: number, assertion: PasskeyAssertion, yParity: boolean): ChainCall;
 }
 
 /**
@@ -501,6 +292,129 @@ declare class StarknetDeviceSigner extends Signer {
     protected signRaw(msgHash: string): Promise<ArraySignatureType>;
 }
 
+/** Starknet network presets and well-known addresses for the kit. */
+declare const STARKNET_NETWORKS: {
+    readonly sepolia: {
+        readonly chainId: "0x534e5f5345504f4c4941";
+        readonly rpcUrl: "https://api.cartridge.gg/x/starknet/sepolia";
+    };
+    readonly mainnet: {
+        readonly chainId: "0x534e5f4d41494e";
+        readonly rpcUrl: "https://api.cartridge.gg/x/starknet/mainnet";
+    };
+};
+type StarknetNetwork = keyof typeof STARKNET_NETWORKS;
+/** Universal Deployer Contract (same address on mainnet & sepolia). */
+declare const UDC_ADDRESS = "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf";
+/**
+ * DeviceAccount class hash, per network. Populated from
+ * `account-contracts/starknet/deployments/<network>.json` after declaring.
+ *
+ * Sepolia re-declared 2026-07-01 with the passkey-approval surface + BATCHED
+ * multi-chain challenge (one passkey prompt approves a device on all chains).
+ * Mainnet still runs the prior class (no passkey) until it is re-declared.
+ */
+declare const DEVICE_ACCOUNT_CLASS_HASH: Record<StarknetNetwork, string>;
+
+interface StellarAdapterOptions {
+    network: StellarNetwork;
+    /** RPC override (else the network default). */
+    rpcUrl?: string;
+    /** Factory contract id override (else the per-network default). */
+    factoryId?: string;
+    /** The device signer that authorizes account operations. */
+    signer: DeviceSigner;
+}
+/**
+ * Stellar / Soroban implementation of the Cavos device-account surface. Unlike
+ * Starknet (`buildSignature(txHash: bigint)`) the Soroban signing unit is a
+ * 32-byte Soroban *auth-entry* preimage, so — as the Solana adapter did for its
+ * own model — this adapter exposes chain-native methods rather than the generic
+ * `ChainAdapter` shape. Its job:
+ *   - derive the deterministic account address off-chain (matches the factory),
+ *   - build the factory/account/token invocations as host functions, and
+ *   - sign a Soroban authorization entry with the silent P-256 device key,
+ *     producing the `Vec<DeviceSignature>` ScVal that the contract's
+ *     `__check_auth` verifies.
+ */
+declare class StellarAdapter {
+    readonly chain: "stellar";
+    readonly network: StellarNetwork;
+    readonly passphrase: string;
+    private readonly rpcUrl;
+    private readonly factoryId;
+    private readonly signer;
+    private _server?;
+    constructor(opts: StellarAdapterOptions);
+    server(): rpc.Server;
+    private networkId;
+    /**
+     * Deterministic account address for `(addressSeed, initialSigner)` — computed
+     * off-chain, byte-identical to the factory's on-chain `account_address`.
+     * `contractId = sha256(HashIdPreimage(networkId, factory, salt))` with
+     * `salt = sha256(addressSeed || sec1(initialSigner))`.
+     */
+    computeAddress(addressSeed: Uint8Array, initialSigner: DevicePublicKey): string;
+    /** `salt = sha256(addressSeed(32) || sec1(initialSigner)(65))` — matches the factory. */
+    accountSalt(addressSeed: Uint8Array, initialSigner: DevicePublicKey): Buffer;
+    /** Host function: `factory.deploy(address_seed, initial_signer)`. */
+    buildDeploy(addressSeed: Uint8Array, initialSigner: DevicePublicKey): xdr.HostFunction;
+    /** Host function: `account.add_signer(new_signer)` (requires device auth). */
+    buildAddSigner(accountAddress: string, signer: DevicePublicKey): xdr.HostFunction;
+    /** Host function: `account.remove_signer(signer)` (requires device auth). */
+    buildRemoveSigner(accountAddress: string, signer: DevicePublicKey): xdr.HostFunction;
+    /** Host function: `account.add_approver(passkey)` (requires device auth). */
+    buildAddApprover(accountAddress: string, passkey: DevicePublicKey): xdr.HostFunction;
+    /** Host function: `account.remove_approver(passkey)` (requires device auth). */
+    buildRemoveApprover(accountAddress: string, passkey: DevicePublicKey): xdr.HostFunction;
+    /** This chain's leaf for approving `add_signer(newSigner)` at `nonce`:
+     * `sha256(sec1(new_signer) || nonce_be8)`. The batch challenge the passkey signs
+     * is `sha256(concat(leaves))` across chains. */
+    passkeyLeaf(newSigner: DevicePublicKey, nonce: bigint): Uint8Array;
+    /** Host function: passkey-authorized `add_signer_via_passkey` (no device auth —
+     * authorized by the embedded WebAuthn assertion, so any relayer can submit).
+     * `leaves`/`leafIndex` place this chain's leaf in the multi-chain batch. */
+    buildAddSignerViaPasskey(accountAddress: string, newSigner: DevicePublicKey, passkey: DevicePublicKey, nonce: bigint, leaves: Uint8Array[], leafIndex: number, assertion: PasskeyAssertion): xdr.HostFunction;
+    /** Read whether `passkey` is a registered approver (read-only simulation). */
+    isApprover(accountAddress: string, passkey: DevicePublicKey, readSource: string): Promise<boolean>;
+    /** Read the current passkey-approval nonce (read-only simulation). */
+    passkeyNonce(accountAddress: string, readSource: string): Promise<bigint>;
+    /** Host function: SEP-41 `token.transfer(from=account, to, amount)` (device auth). */
+    buildTransfer(tokenId: string, accountAddress: string, destination: string, amount: bigint): xdr.HostFunction;
+    /**
+     * Sign a Soroban authorization entry with the silent device key, producing the
+     * `Vec<DeviceSignature>` the account's `__check_auth` verifies. The device
+     * signs `sha256(preimage)` (WebCrypto hashes once more internally), which is
+     * exactly what the contract recomputes. Mutates + returns the entry.
+     */
+    signAuthEntry(entry: xdr.SorobanAuthorizationEntry, validUntilLedger: number): Promise<xdr.SorobanAuthorizationEntry>;
+    /**
+     * Read a SEP-41 token balance of `account` via a read-only simulation of
+     * `token.balance(account)`. Returns 0 when the account isn't deployed or holds
+     * none. `readSource` is any funded G-account (used only for the simulation).
+     */
+    readBalance(tokenId: string, account: string, readSource: string): Promise<bigint>;
+    /** Whether the account contract instance exists on-chain (is deployed). */
+    isDeployed(accountAddress: string): Promise<boolean>;
+    /**
+     * Read whether `signer` is a currently-authorized signer of the account, via a
+     * read-only simulation of `account.is_authorized(signer)`. `readSource` is any
+     * funded G-account (used only for the simulation's source/sequence).
+     */
+    isAuthorizedSigner(accountAddress: string, signer: DevicePublicKey, readSource: string): Promise<boolean>;
+}
+/** SEC-1 uncompressed P-256 public key (65 bytes: 0x04 || X || Y). */
+declare function sec1Pubkey(pk: DevicePublicKey): Uint8Array;
+/** Raw 64-byte `r || s`, normalized to low-S (secp256r1_verify requires it). */
+declare function encodeLowSSignature(sig: DeviceSignature): Uint8Array;
+/**
+ * The `Vec<DeviceSignature>` ScVal the contract's `__check_auth` decodes. Each
+ * element is a struct `{ public_key: BytesN<65>, signature: BytesN<64> }`.
+ * Soroban serializes a struct as a symbol-keyed map sorted by key; `public_key`
+ * precedes `signature`, so `nativeToScVal` (which sorts) yields the exact layout.
+ */
+declare function deviceSignatureScVal(pubkey: DevicePublicKey, sig: DeviceSignature): xdr.ScVal;
+
 /**
  * Serialize a device signature to the felt array for `tx_info.signature`:
  *   [ r_low, r_high, s_low, s_high, y_parity ]
@@ -526,4 +440,4 @@ declare function hexToBytes(hex: string): Uint8Array;
 /** A felt/bigint -> 32-byte big-endian Uint8Array (the tx-hash width). */
 declare function bigIntTo32Bytes(value: bigint): Uint8Array;
 
-export { type AuthProvider, BackupSigner, Cavos, CavosAuth, type CavosAuthOptions, ChainAdapter, ChainCall, ComputeAddressParams, type ConnectOptions, type ConnectStatus, DevicePublicKey, DeviceSignature, DeviceSigner, HttpRecoveryClient, type HttpRecoveryClientOptions, HttpWalletRegistry, type HttpWalletRegistryOptions, type Identity, type IdentityInput, InMemoryWalletRegistry, type PendingDeviceRequest, type RecoveryClient, type RecoveryOptions, type RegisteredWallet, StarknetAdapter, type StarknetAdapterOptions, StarknetDeviceSigner, StarknetNetwork, StaticIdentity, type WalletRegistry, WebCryptoSigner, type WebCryptoSignerOptions, bigIntTo32Bytes, bytesToBigInt, bytesToHex, deriveAddressSeed, deriveBackupKey, generateRecoveryCode, hexToBytes, recoverYParity, signatureToFelts, u256ToFelts };
+export { AuthProvider, BackupSigner, CavosAuth, type CavosAuthOptions, ChainAdapter, ChainCall, ComputeAddressParams, DEVICE_ACCOUNT_CLASS_HASH, DevicePublicKey, DeviceSignature, DeviceSigner, HttpRecoveryClient, type HttpRecoveryClientOptions, HttpWalletRegistry, type HttpWalletRegistryOptions, Identity, type IdentityInput, PasskeyAssertion, PendingDeviceRequest, RecoveryClient, RegisteredWallet, STARKNET_NETWORKS, StarknetAdapter, type StarknetAdapterOptions, StarknetDeviceSigner, type StarknetNetwork, StellarAdapter, type StellarAdapterOptions, StellarNetwork, UDC_ADDRESS, WalletRegistry, WebCryptoSigner, type WebCryptoSignerOptions, bigIntTo32Bytes, bytesToBigInt, bytesToHex, deriveAddressSeed, deriveAddressSeedSolana, deriveAddressSeedStellar, deriveBackupKey, deviceSignatureScVal, encodeLowSSignature as encodeStellarLowSSignature, generateRecoveryCode, hexToBytes, recoverYParity, sec1Pubkey, signatureToFelts, u256ToFelts };