@domino-sdk/relay 1.67.0 → 1.68.0

package/dist/{wallet-Btng186v.d.ts → wallet-DQtJelQQ.d.ts}

@@ -32,6 +32,59 @@ declare const profileDefaultsSchema: z.ZodArray<z.ZodEnum<{
     x: "x";
 }>>;
 type ProfileDefaults = z.infer<typeof profileDefaultsSchema>;
+/**
+ * The sources a project can list as profile defaults: the `profileDefaultProviderSchema` accounts,
+ * and `sol`, the primary `.sol` name of a Solana wallet the member linked. A `.sol` name supplies a
+ * name only, never a picture. Settings answer the full list in `defaultSources`.
+ *
+ * @experimental A minor release can change `.sol` names.
+ */
+declare const knownProfileDefaultSources: readonly ["x", "discord", "sol"];
+/**
+ * A default source this SDK knows.
+ *
+ * @compat open
+ * @experimental A minor release can change `.sol` names.
+ */
+type KnownProfileDefaultSource = (typeof knownProfileDefaultSources)[number];
+/**
+ * A profile default source: one of `knownProfileDefaultSources`, or one a later Relay adds.
+ *
+ * @experimental A minor release can change `.sol` names.
+ */
+type ProfileDefaultSource = KnownProfileDefaultSource | (string & {});
+/**
+ * The default sources a settings change can list, in order, each once.
+ *
+ * @experimental A minor release can change `.sol` names.
+ */
+declare const profileDefaultSourcesSchema: z.ZodArray<z.ZodEnum<{
+    discord: "discord";
+    x: "x";
+    sol: "sol";
+}>>;
+/**
+ * Where a member's chosen name comes from instead of a name they typed: `sol` follows the primary
+ * `.sol` name of a Solana wallet they linked.
+ *
+ * @experimental A minor release can change `.sol` names.
+ */
+declare const profileNameSourceSchema: z.ZodEnum<{
+    sol: "sol";
+}>;
+/**
+ * A name source this SDK knows.
+ *
+ * @compat open
+ * @experimental A minor release can change `.sol` names.
+ */
+type KnownProfileNameSource = z.infer<typeof profileNameSourceSchema>;
+/**
+ * A profile name source, or one a later Relay adds.
+ *
+ * @experimental A minor release can change `.sol` names.
+ */
+type ProfileNameSource = KnownProfileNameSource | (string & {});
 /**
  * The seed of a generated avatar (`defaultAvatar`), the same one `relay.me.get()` returns: an HMAC
  * of the member under the project's secret, so it reveals nothing about the member.
@@ -91,10 +144,15 @@ declare const displayNameSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform
 /**
  * A change to the member's own profile; omitted fields stay. `displayName: null` and
  * `avatar: null` return to the project's defaults (null also removes an uploaded picture).
- * Upload a picture with `relay.profiles.uploadAvatar`.
+ * `nameSource: "sol"` shows the member's `.sol` name (one of `nameOptions`) and keeps following
+ * it; a `displayName`, or `nameSource: null`, stops following it. Upload a picture with
+ * `relay.profiles.uploadAvatar`.
  */
 declare const profileUpdateSchema: z.ZodObject<{
     displayName: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>>;
+    nameSource: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        sol: "sol";
+    }>>>;
     avatar: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
         source: z.ZodLiteral<"account">;
         provider: z.ZodEnum<{
@@ -158,6 +216,11 @@ declare const ownProfileSchema: z.ZodObject<{
         givenName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
         imageUrl: z.ZodNullable<z.ZodString>;
     }, z.core.$strip>>;
+    nameSource: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    nameOptions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 /** @compat output */
 type OwnProfile = z.infer<typeof ownProfileSchema>;
@@ -216,6 +279,7 @@ declare const profileSettingsSchema: z.ZodObject<{
         discord: "discord";
         x: "x";
     }>>;
+    defaultSources: z.ZodOptional<z.ZodArray<z.ZodString>>;
     revision: z.ZodNumber;
     actor: z.ZodNullable<z.ZodString>;
     updatedAt: z.ZodNullable<z.ZodNumber>;
@@ -231,6 +295,11 @@ declare const profileSettingsInputSchema: z.ZodObject<{
         discord: "discord";
         x: "x";
     }>>;
+    defaultSources: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        discord: "discord";
+        x: "x";
+        sol: "sol";
+    }>>>;
     actionId: z.ZodString;
     expectedRevision: z.ZodNumber;
     reason: z.ZodString;
@@ -274,6 +343,7 @@ declare const managedProfileSchema: z.ZodObject<{
         source: z.ZodLiteral<"generated">;
         seed: z.ZodString;
     }, z.core.$strip>], "source">;
+    nameSource: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     avatarChoice: z.ZodEnum<{
         default: "default";
         account: "account";
@@ -390,6 +460,51 @@ type EvmChainId = `eip155:${number}`;
 declare function isEvmChainId(value: string): value is EvmChainId;
 /** {@link isEvmChainId} as a schema. */
 declare const evmChainIdSchema: z.ZodCustom<`eip155:${number}`, `eip155:${number}`>;
+/** The SPL Memo program (v2), whose instruction fails unless every account it lists signed. */
+declare const solanaMemoProgram = "MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr";
+/** A Solana transaction signature: base58, 64 bytes. */
+declare const solanaSignatureSchema: z.ZodString;
+/**
+ * What a Solana account that cannot sign messages, such as a Squads vault, puts on chain to prove
+ * it is the member's: a transaction it executes with an SPL Memo instruction carrying `memo` and
+ * listing the account. Not strict: newer servers may add fields.
+ *
+ * @experimental A minor release can change linking by transaction.
+ */
+declare const walletTransactionChallengeSchema: z.ZodObject<{
+    id: z.ZodString;
+    chain: z.ZodEnum<{
+        solana: "solana";
+        eip155: "eip155";
+        cosmos: "cosmos";
+    }>;
+    address: z.ZodString;
+    memo: z.ZodString;
+    memoProgram: z.ZodString;
+    expiresAt: z.ZodNumber;
+}, z.core.$strip>;
+/** @experimental */
+type WalletTransactionChallenge = z.infer<typeof walletTransactionChallengeSchema>;
+/**
+ * The transaction that carries a challenge's memo, for the account it proves.
+ *
+ * @experimental A minor release can change linking by transaction.
+ */
+declare const walletTransactionProofSchema: z.ZodObject<{
+    chain: z.ZodLiteral<"solana">;
+    address: z.ZodString;
+    signature: z.ZodString;
+}, z.core.$strict>;
+/** @experimental */
+type WalletTransactionProof = z.infer<typeof walletTransactionProofSchema>;
+/**
+ * How a wallet proved it is the member's, when not by signing a message.
+ *
+ * @compat open
+ */
+type KnownWalletProofKind = "transaction";
+/** A known proof kind, or one a newer Relay sends. */
+type WalletProofKind = KnownWalletProofKind | (string & {});
 declare const linkedWalletSchema: z.ZodObject<{
     chain: z.ZodEnum<{
         solana: "solana";
@@ -399,6 +514,8 @@ declare const linkedWalletSchema: z.ZodObject<{
     network: z.ZodNullable<z.ZodCustom<`cosmos:${string}`, `cosmos:${string}`>>;
     address: z.ZodString;
     provedOn: z.ZodOptional<z.ZodCustom<`eip155:${number}`, `eip155:${number}`>>;
+    provedBy: z.ZodOptional<z.ZodType<WalletProofKind, unknown, z.core.$ZodTypeInternals<WalletProofKind, unknown>>>;
+    proofTransaction: z.ZodOptional<z.ZodString>;
     verifiedAt: z.ZodNumber;
     revision: z.ZodNumber;
     signIn: z.ZodBoolean;
@@ -551,19 +668,67 @@ declare const walletBalanceSampleSchema: z.ZodObject<{
 type WalletBalanceSample = z.infer<typeof walletBalanceSampleSchema>;
 /** What `wallet.balances()` samples: a `ctx.wallet.balance()` query without an address. */
 type WalletBalanceSourceQuery = WalletBalanceQuery extends infer Query ? Query extends unknown ? Omit<Query, "address"> : never : never;
+
+/**
+ * One finalized, successful Solana transaction of a member's linked wallet that called the
+ * tracker's program, as Relay recorded it for a `wallet.programActivity()` tracker: the record's
+ * `data`. The record's ID is the signature, its author the wallet's CAIP-10 account on the
+ * tracker's cluster, and its `occurredAt` the block time.
+ *
+ * @compat output
+ */
+declare const walletProgramActivitySchema: z.ZodObject<{
+    signature: z.ZodString;
+    slot: z.ZodString;
+    timestamp: z.ZodNumber;
+    signer: z.ZodBoolean;
+    instruction: z.ZodNullable<z.ZodString>;
+    amount: z.ZodNullable<z.ZodString>;
+    delta: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/** One transaction a `wallet.programActivity()` tracker recorded: its records' `data`. */
+type WalletProgramActivity = z.infer<typeof walletProgramActivitySchema>;
+/** What `wallet.programActivity()` records. */
+type WalletProgramActivitySourceQuery = {
+    /**
+     * The cluster: `"solana"` or {@link solanaMainnet} for mainnet (the default), {@link solanaDevnet}
+     * for devnet.
+     */
+    chain?: "solana" | SolanaNetwork;
+    /** The program's address (base58). */
+    program: string;
+    /**
+     * Count only transactions that call this instruction of the program, by the name its IDL
+     * gives it. The program must publish an IDL Relay can read, as for `settings.solanaProgram()`.
+     */
+    instruction?: string;
+    /** Count only transactions that change the wallet's balance of this SPL mint (base58). */
+    mint?: string;
+    /**
+     * With `mint`: count only transactions that move at least this many base units of it in or out of
+     * the wallet, as a decimal integer string.
+     */
+    minAmount?: string;
+    /**
+     * `"wallet"` (the default) counts only transactions the wallet signed. `"any"` also counts ones
+     * someone else signed that name the wallet, such as a transfer into it.
+     */
+    signer?: "wallet" | "any";
+};
 /**
  * An NFT standard `ctx.wallet.nfts()` reads: an ERC-721 or ERC-1155 contract on an EVM chain, or a
- * Metaplex verified collection on Solana mainnet or devnet.
+ * Metaplex collection on Solana mainnet or devnet: a Core collection or a Token Metadata verified
+ * collection.
  */
 type NftStandard = "erc721" | "erc1155" | "metaplex";
 /**
  * An NFT collection as a CAIP-19 asset type. On an EVM chain: the chain, the contract's standard
  * and its address, such as `"eip155:1/erc721:0xBC4CA0EdA7647A8aB7C2061c2E118A18a936f13D"`; an
  * ERC-1155 collection names one token ID after the contract: `"eip155:8453/erc1155:0x…/1"`. On
- * Solana: the cluster and the Metaplex collection NFT's mint, such as
- * `"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/nft:<mint>"` on mainnet or
- * `"solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1/nft:<mint>"` on devnet, which stands for every NFT
- * whose metadata names that collection as verified.
+ * Solana: the cluster and the address of a Metaplex Core collection or of a Token Metadata
+ * collection NFT's mint, such as `"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/nft:<address>"` on
+ * mainnet or `"solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1/nft:<address>"` on devnet, which stands for
+ * every Core asset in that collection and every NFT whose metadata names it as verified.
  */
 type NftCollection = `${EvmChainId}/erc721:0x${string}` | `${EvmChainId}/erc1155:0x${string}/${string}` | `${SolanaNetwork}/nft:${string}`;
 /** The parts of an NFT collection ({@link parseNftCollection}). */
@@ -575,7 +740,7 @@ type NftCollectionParts = {
 } | {
     chain: SolanaNetwork;
     standard: "metaplex";
-    /** The Metaplex collection NFT's mint (base58). */
+    /** The Core collection's address or the collection NFT's mint (base58). */
     mint: string;
 };
 /**
@@ -618,6 +783,22 @@ declare const walletNftsSchema: z.ZodObject<{
     observedAt: z.ZodNumber;
 }, z.core.$strict>;
 type WalletNfts = z.infer<typeof walletNftsSchema>;
+
+/**
+ * One wallet's holding as Relay sampled it for a `wallet.nfts()` tracker, the record's `data`. The
+ * record's ID and author are the wallet's CAIP-10 account on the collection's chain, and its
+ * `occurredAt` is when Relay sampled it.
+ *
+ * @compat output
+ */
+declare const walletNftSampleSchema: z.ZodObject<{
+    count: z.ZodString;
+    block: z.ZodString;
+}, z.core.$strip>;
+/** One wallet's sampled NFT holding, the `data` of a `wallet.nfts()` tracker's record. */
+type WalletNftSample = z.infer<typeof walletNftSampleSchema>;
+/** What `wallet.nfts()` samples: a `ctx.wallet.nfts()` query without an address. */
+type WalletNftSourceQuery = Omit<WalletNftsQuery, "address">;
 /** The ABI types a contract call's single return value may have. */
 type ContractCallReturnType = `uint${number}` | `int${number}` | "bool" | "address";
 /** A view or pure function's signature, parsed ({@link parseContractFunction}). */
@@ -853,7 +1034,7 @@ type SolanaProgram = string;
  */
 declare function isSolanaProgram(value: string): value is SolanaProgram;
 /**
- * A Solana program's Anchor IDL, legacy or 0.30+, as JSON. Relay checks its instructions when it is
+ * A Solana program's IDL as JSON: Anchor (legacy or 0.30+), Codama or Shank. Relay checks its instructions when it is
  * pasted or fetched.
  */
 declare const anchorIdlSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
@@ -863,7 +1044,7 @@ type KnownSolanaIdlSource = "chain" | "pasted";
 /** A known IDL source, or one a newer Relay sends. */
 type SolanaIdlSource = KnownSolanaIdlSource | (string & {});
 /**
- * The Anchor IDL a `settings.solanaProgram()` setting decodes instructions with: fetched from the
+ * The IDL a `settings.solanaProgram()` setting decodes instructions with: fetched from the
  * program's on-chain IDL when the setting was saved (`"chain"`), or pasted by an operator, which
  * takes precedence over the on-chain one (`"pasted"`).
  */
@@ -950,8 +1131,155 @@ declare const walletTransactionsSchema: z.ZodObject<{
 type WalletTransactions = z.infer<typeof walletTransactionsSchema>;
 /** One transaction `ctx.wallet.transactions()` returns. */
 type WalletTransaction = WalletTransactions["transactions"][number];
-/** One program instruction of a transaction, decoded with the program's Anchor IDL. */
+/** One program instruction of a transaction, decoded with the program's IDL. */
 type WalletInstruction = NonNullable<WalletTransaction["instructions"]>[number];
+/**
+ * Transactions to read as a testing-kit `facts.wallet.transactions` answer
+ * (`management.solana.transactionFixture()`).
+ */
+declare const solanaTransactionFixtureInputSchema: z.ZodObject<{
+    chain: z.ZodDefault<z.ZodEnum<{
+        "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+        "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+    }>>;
+    program: z.ZodString;
+    signatures: z.ZodArray<z.ZodString>;
+    wallet: z.ZodOptional<z.ZodString>;
+    idl: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+}, z.core.$strict>;
+/** What `management.solana.transactionFixture()` reads. */
+type SolanaTransactionFixtureInput = z.input<typeof solanaTransactionFixtureInputSchema>;
+/** The integer types a program-account seed can have, written little-endian as Rust's `to_le_bytes()`. */
+type SolanaSeedInteger = "u8" | "u16" | "u32" | "u64" | "u128" | "i8" | "i16" | "i32" | "i64" | "i128";
+/**
+ * One seed of a program-derived address: `{ wallet: true }` for each linked wallet's address, a
+ * string for its UTF-8 bytes, `{ pubkey }` for an address's 32 bytes, or an integer as
+ * `{ u64: value }` (any {@link SolanaSeedInteger}), its value a safe integer number or a decimal
+ * string. Seeds other than the wallet come from code or settings, never from member input.
+ */
+type SolanaSeed = {
+    wallet: true;
+} | string | {
+    pubkey: string;
+} | {
+    [K in SolanaSeedInteger]: {
+        [P in K]: number | string;
+    };
+}[SolanaSeedInteger];
+/** A program-account seed as the sandbox sends it. Syntax only: Relay checks lengths and ranges. */
+declare const solanaSeedSchema: z.ZodType<SolanaSeed>;
+/** The most seeds a program-derived address takes besides its bump, as Solana allows. */
+declare const maxSolanaSeeds = 15;
+/** What `ctx.wallet.programAccount()` reads. */
+type WalletProgramAccountQuery = {
+    /** The program, from a `settings.solanaProgram()` setting whose IDL Relay stored. */
+    program: SolanaProgram;
+    /** The account type, as the program's IDL names it in `accounts`, such as `"UserStake"`. */
+    account: string;
+    /**
+     * The seeds the program derives each member's account from, in order, such as
+     * `["stake", { wallet: true }]`. `{ wallet: true }` must appear at least once.
+     */
+    seeds: SolanaSeed[];
+    /**
+     * The cluster to read: `"solana"` or {@link solanaMainnet} for mainnet (the default),
+     * {@link solanaDevnet} for devnet.
+     */
+    chain?: "solana" | SolanaNetwork;
+    /** One of the member's linked Solana wallets; omit to read all of them. */
+    address?: string;
+};
+/** @compat open */
+type KnownProgramAccountPointKind = "slot";
+/** What a program-account read's `at` counts: a known kind, or one a newer Relay sends. */
+type ProgramAccountPointKind = KnownProgramAccountPointKind | (string & {});
+/**
+ * One account type of a Solana program, read at the address each of the member's pinned linked
+ * Solana wallets derives, and decoded with the program's IDL.
+ */
+declare const walletProgramAccountSchema: z.ZodObject<{
+    program: z.ZodString;
+    chain: z.ZodString;
+    account: z.ZodString;
+    wallets: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        pda: z.ZodString;
+        fields: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodJSONSchema>>;
+    }, z.core.$strip>>;
+    at: z.ZodObject<{
+        kind: z.ZodType<ProgramAccountPointKind>;
+        number: z.ZodString;
+    }, z.core.$strip>;
+    observedAt: z.ZodNumber;
+}, z.core.$strip>;
+/** What `ctx.wallet.programAccount()` returns: each linked wallet's account, decoded. */
+type WalletProgramAccount = z.infer<typeof walletProgramAccountSchema>;
+/** What `ctx.wallet.stake()` reads. */
+type WalletStakeQuery = {
+    /**
+     * The cluster to read: `"solana"` or {@link solanaMainnet} for mainnet (the default),
+     * {@link solanaDevnet} for devnet.
+     */
+    chain?: "solana" | SolanaNetwork;
+    /** A validator's vote account (base58); omit to count every validator. */
+    voteAccount?: string;
+    /** One of the member's linked Solana wallets; omit to read all of them. */
+    address?: string;
+};
+/** @compat open */
+type KnownStakePointKind = "slot";
+/** What a stake read's `at` counts: a known kind, or one a newer Relay sends. */
+type StakePointKind = KnownStakePointKind | (string & {});
+/**
+ * The SOL the member's pinned linked Solana wallets delegate through stake accounts they control,
+ * as staker or withdrawer, at one epoch. Amounts are lamports.
+ */
+declare const walletStakeSchema: z.ZodObject<{
+    chain: z.ZodString;
+    voteAccount: z.ZodNullable<z.ZodString>;
+    epoch: z.ZodNumber;
+    total: z.ZodString;
+    activating: z.ZodString;
+    deactivating: z.ZodString;
+    wallets: z.ZodArray<z.ZodObject<{
+        amount: z.ZodString;
+        activating: z.ZodString;
+        deactivating: z.ZodString;
+        address: z.ZodString;
+    }, z.core.$strip>>;
+    voteAccounts: z.ZodArray<z.ZodObject<{
+        amount: z.ZodString;
+        activating: z.ZodString;
+        deactivating: z.ZodString;
+        voteAccount: z.ZodString;
+    }, z.core.$strip>>;
+    at: z.ZodObject<{
+        kind: z.ZodType<StakePointKind>;
+        number: z.ZodString;
+    }, z.core.$strip>;
+    observedAt: z.ZodNumber;
+}, z.core.$strip>;
+/** What `ctx.wallet.stake()` returns: the SOL the member's linked wallets delegate. */
+type WalletStake = z.infer<typeof walletStakeSchema>;
+
+/**
+ * One wallet's stake as Relay sampled it for a `wallet.stake()` tracker, the record's `data`, in
+ * lamports, counted as `ctx.wallet.stake({ address })` counts that wallet's. The record's ID and
+ * author are the wallet's CAIP-10 account on the tracker's cluster, and its `occurredAt` is when
+ * Relay sampled it.
+ *
+ * @compat output
+ */
+declare const walletStakeSampleSchema: z.ZodObject<{
+    amount: z.ZodString;
+    activating: z.ZodString;
+    deactivating: z.ZodString;
+    block: z.ZodString;
+}, z.core.$strip>;
+/** One wallet's sampled stake, the `data` of a `wallet.stake()` tracker's record. */
+type WalletStakeSample = z.infer<typeof walletStakeSampleSchema>;
+/** What `wallet.stake()` samples: a `ctx.wallet.stake()` query without an address. */
+type WalletStakeSourceQuery = Omit<WalletStakeQuery, "address">;
 /**
  * Reads the wallets the member has linked to this project. They are pinned once per attempt, at
  * its first wallet read: later links and unlinks do not change the attempt. Every method resolves
@@ -972,8 +1300,9 @@ interface WalletReader {
     /**
      * How many NFTs of one collection the member's linked wallets of its family hold: an ERC-721
      * contract's `balanceOf(owner)`, one ERC-1155 token ID's `balanceOf(owner, id)`, or on Solana the
-     * NFTs whose Metaplex metadata names the collection as verified, summed and per wallet.
-     * Compressed NFTs and Metaplex Core assets on Solana are not counted. Null when the member has no linked wallet of that family. A malformed collection, a
+     * Metaplex Core assets in the collection or the NFTs whose Metaplex metadata names it as
+     * verified, plus the compressed NFTs (Bubblegum) verified into it, summed and per wallet. Null when the
+     * member has no linked wallet of that family. A malformed collection, a
      * chain Relay does not read and an `address` the member never linked throw `CapabilityError`
      * with code `"author-error"`. Relay supplies it to every evaluation; it is optional only so that
      * test doubles written before it keep compiling.
@@ -1028,6 +1357,31 @@ interface WalletReader {
      * evaluation; it is optional only so that test doubles written before it keep compiling.
      */
     transactions?(query: WalletTransactionsQuery): Promise<WalletTransactions | null>;
+    /**
+     * One account type of a program, per linked Solana wallet: derives the program-derived
+     * address from `seeds` with `{ wallet: true }` as each wallet's address, reads every account at
+     * one slot, and decodes its fields with the program's IDL. A wallet whose account does
+     * not exist reads `fields: null`. Use it for state a program keeps per user, such as a stake
+     * account. Null when the member has no linked Solana wallet. A malformed program, a program
+     * whose setting has no IDL, an account type the IDL does not name, seeds that do not fit
+     * (no `{ wallet: true }`, a seed over 32 bytes, an integer out of range), a program that is not
+     * executable on the cluster, an account owned by another program or holding another account
+     * type, and an `address` the member never linked throw `CapabilityError` with code
+     * `"author-error"`. Relay supplies it to every evaluation; it is optional only so that test
+     * doubles written before it keep compiling.
+     */
+    programAccount?(query: WalletProgramAccountQuery): Promise<WalletProgramAccount | null>;
+    /**
+     * The SOL the member's linked Solana wallets delegate through native stake accounts, at one
+     * epoch: every Stake program account where a wallet is the staker or the withdrawer, counted
+     * once. `total` is active stake; stake activating or deactivating this epoch is reported apart,
+     * so a quest can count it or not. Summed, per wallet and per vote account, or only to
+     * `voteAccount`, in lamports. Null when the member has no linked Solana wallet. A malformed vote
+     * account and an `address` the member never linked throw `CapabilityError` with code
+     * `"author-error"`. Relay supplies it to every evaluation; it is optional only so that test
+     * doubles written before it keep compiling.
+     */
+    stake?(query: WalletStakeQuery): Promise<WalletStake | null>;
 }
 
-export { type WalletNftsQuery as $, type AvatarProvider as A, type ContractEventParts as B, type CosmosChain as C, type ContractFunction as D, type CosmosDenom as E, type EvmChainId as F, type NftCollectionParts as G, type NftStandard as H, type WalletBalance as I, type WalletBalanceChange as J, type WalletBalanceSample as K, type LinkedWallet as L, type WalletCall as M, type NftCollection as N, type OwnProfile as O, type ProfileAvatar as P, type WalletCallArgument as Q, type WalletCallQuery as R, type SolanaIdlSource as S, type WalletDelegations as T, type WalletDelegationsQuery as U, type WalletEventCondition as V, type WalletAddressInput as W, type WalletEventValue as X, type WalletEvents as Y, type WalletEventsQuery as Z, type WalletNfts as _, type CosmosNetwork as a, walletBalanceSampleSchema as a$, type WalletTransactions as a0, type WalletTransactionsQuery as a1, cosmosDenomSchema as a2, cosmosNetworkSchema as a3, isContractCall as a4, isContractEvent as a5, isEvmChainId as a6, isNftCollection as a7, isSolanaProgram as a8, maxWalletEventLogs as a9, caip10 as aA, cosmosAddressSchema as aB, cosmosChain as aC, displayNameSchema as aD, evmAddressSchema as aE, evmChainIdSchema as aF, isSolanaNetwork as aG, linkedWalletSchema as aH, managedProfileSchema as aI, ownProfileSchema as aJ, profileAvatarSchema as aK, profileCompletionPageSchema as aL, profileCompletionQuerySchema as aM, profileCompletionSchema as aN, profileDefaultProviderSchema as aO, profileDefaultsSchema as aP, profileModerationSchema as aQ, profileReferralSchema as aR, profileSettingsInputSchema as aS, profileSettingsSchema as aT, profileSummarySchema as aU, profileVisibilitySchema as aV, solanaAddressSchema as aW, solanaDevnet as aX, solanaMainnet as aY, solanaProgramIdlSchema as aZ, walletAddressInput as a_, maxWalletEventLookback as aa, maxWalletTransactionLookback as ab, maxWalletTransactions as ac, parseContractCall as ad, parseContractEvent as ae, parseContractFunction as af, parseNftCollection as ag, profileUpdateSchema as ah, walletAddressInputSchema as ai, walletSignatureSchema as aj, AVATAR_UPLOAD_LIMIT as ak, type AnchorIdl as al, type KnownSolanaIdlSource as am, type ManagedProfile as an, type ProfileDefaultProvider as ao, type ProfileDefaults as ap, type ProfileModeration as aq, type ProfileSettings as ar, type ProfileSettingsInput as as, type SolanaNetwork as at, type SolanaProgramIdl as au, WALLETS_PER_CHAIN as av, anchorIdlSchema as aw, avatarProviderSchema as ax, avatarSeedSchema as ay, avatarUploadTypes as az, type ProfileCompletion as b, walletBalanceSchema as b0, walletCallSchema as b1, walletChainSchema as b2, walletDelegationsSchema as b3, walletEventsSchema as b4, walletMessageChallengeSchema as b5, walletNftsSchema as b6, walletSignInFamilies as b7, walletSignInNetwork as b8, walletSignInNetworkSchema as b9, walletSignInNetworksSchema as ba, walletTransactionsSchema as bb, walletUnlinkInputSchema as bc, type ProfileCompletionPage as c, type ProfileCompletionQuery as d, type ProfileReferral as e, type ProfileSummary as f, type ProfileUpdate as g, type ProfileVisibility as h, type WalletChain as i, type WalletMessageChallenge as j, type WalletSignInNetwork as k, type WalletSignature as l, type WalletSigner as m, type WalletUnlinkInput as n, type WalletBalanceQuery as o, evmWalletOn as p, type ContractCall as q, type ContractEvent as r, type SolanaProgram as s, type WalletBalanceSourceQuery as t, type WalletTransaction as u, type WalletInstruction as v, type WalletReader as w, type ContractCallParts as x, type ContractCallReturnType as y, type ContractEventInput as z };
+export { type WalletBalanceSample as $, type AvatarProvider as A, type WalletProgramActivitySourceQuery as B, type CosmosChain as C, type WalletNftSourceQuery as D, type WalletStakeSourceQuery as E, type WalletTransaction as F, type WalletInstruction as G, type WalletReader as H, type ContractCallParts as I, type ContractCallReturnType as J, type ContractEventInput as K, type LinkedWallet as L, type ContractEventParts as M, type NftCollection as N, type OwnProfile as O, type ProfileAvatar as P, type ContractFunction as Q, type CosmosDenom as R, type SolanaNetwork as S, type EvmChainId as T, type NftCollectionParts as U, type NftStandard as V, type WalletAddressInput as W, type SolanaSeed as X, type SolanaSeedInteger as Y, type WalletBalance as Z, type WalletBalanceChange as _, type CosmosNetwork as a, avatarUploadTypes as a$, type WalletCall as a0, type WalletCallArgument as a1, type WalletCallQuery as a2, type WalletDelegations as a3, type WalletDelegationsQuery as a4, type WalletEventCondition as a5, type WalletEventValue as a6, type WalletEvents as a7, type WalletEventsQuery as a8, type WalletNftSample as a9, walletAddressInputSchema as aA, walletSignatureSchema as aB, walletTransactionProofSchema as aC, evmWalletOn as aD, type ProgramAccountPointKind as aE, type StakePointKind as aF, AVATAR_UPLOAD_LIMIT as aG, type AnchorIdl as aH, type KnownProfileDefaultSource as aI, type KnownProfileNameSource as aJ, type KnownProgramAccountPointKind as aK, type KnownSolanaIdlSource as aL, type KnownStakePointKind as aM, type KnownWalletProofKind as aN, type ManagedProfile as aO, type ProfileDefaultProvider as aP, type ProfileDefaultSource as aQ, type ProfileDefaults as aR, type ProfileModeration as aS, type ProfileSettings as aT, type ProfileSettingsInput as aU, type SolanaProgramIdl as aV, type SolanaTransactionFixtureInput as aW, WALLETS_PER_CHAIN as aX, anchorIdlSchema as aY, avatarProviderSchema as aZ, avatarSeedSchema as a_, type WalletNfts as aa, type WalletNftsQuery as ab, type WalletProgramAccount as ac, type WalletProgramAccountQuery as ad, type WalletProgramActivity as ae, type WalletStake as af, type WalletStakeQuery as ag, type WalletStakeSample as ah, type WalletTransactions as ai, type WalletTransactionsQuery as aj, cosmosDenomSchema as ak, cosmosNetworkSchema as al, isContractCall as am, isContractEvent as an, isEvmChainId as ao, isNftCollection as ap, isSolanaProgram as aq, maxWalletEventLogs as ar, maxWalletEventLookback as as, maxWalletTransactionLookback as at, maxWalletTransactions as au, parseContractCall as av, parseContractEvent as aw, parseContractFunction as ax, parseNftCollection as ay, profileUpdateSchema as az, type ProfileCompletion as b, caip10 as b0, cosmosAddressSchema as b1, cosmosChain as b2, displayNameSchema as b3, evmAddressSchema as b4, evmChainIdSchema as b5, isSolanaNetwork as b6, knownProfileDefaultSources as b7, linkedWalletSchema as b8, managedProfileSchema as b9, walletChainSchema as bA, walletDelegationsSchema as bB, walletEventsSchema as bC, walletMessageChallengeSchema as bD, walletNftsSchema as bE, walletProgramAccountSchema as bF, walletProgramActivitySchema as bG, walletSignInFamilies as bH, walletSignInNetwork as bI, walletSignInNetworkSchema as bJ, walletSignInNetworksSchema as bK, walletStakeSchema as bL, walletTransactionChallengeSchema as bM, walletTransactionsSchema as bN, walletUnlinkInputSchema as bO, maxSolanaSeeds as ba, ownProfileSchema as bb, profileAvatarSchema as bc, profileCompletionPageSchema as bd, profileCompletionQuerySchema as be, profileCompletionSchema as bf, profileDefaultProviderSchema as bg, profileDefaultSourcesSchema as bh, profileDefaultsSchema as bi, profileModerationSchema as bj, profileNameSourceSchema as bk, profileReferralSchema as bl, profileSettingsInputSchema as bm, profileSettingsSchema as bn, profileSummarySchema as bo, profileVisibilitySchema as bp, solanaAddressSchema as bq, solanaMemoProgram as br, solanaProgramIdlSchema as bs, solanaSeedSchema as bt, solanaSignatureSchema as bu, solanaTransactionFixtureInputSchema as bv, walletAddressInput as bw, walletBalanceSampleSchema as bx, walletBalanceSchema as by, walletCallSchema as bz, type ProfileCompletionPage as c, type ProfileCompletionQuery as d, type ProfileNameSource as e, type ProfileReferral as f, type ProfileSummary as g, type ProfileUpdate as h, type ProfileVisibility as i, type WalletChain as j, type WalletMessageChallenge as k, type WalletProofKind as l, type WalletSignInNetwork as m, type WalletSignature as n, type WalletSigner as o, type WalletTransactionChallenge as p, type WalletTransactionProof as q, type WalletUnlinkInput as r, solanaDevnet as s, solanaMainnet as t, type SolanaIdlSource as u, type WalletBalanceQuery as v, type ContractCall as w, type ContractEvent as x, type SolanaProgram as y, type WalletBalanceSourceQuery as z };

package/dist/wallet-browser-dpmr22Xv.d.ts

@@ -0,0 +1,106 @@
+import { C as CosmosChain, a as CosmosNetwork, o as WalletSigner, m as WalletSignInNetwork } from './wallet-DQtJelQQ.js';
+
+/** An EIP-1193 provider, such as `window.ethereum` or an EIP-6963 announcement's provider. */
+type Eip1193Provider = {
+    request(args: {
+        method: string;
+        params?: unknown[] | object;
+    }): Promise<unknown>;
+    /** Subscribes to a provider event such as `accountsChanged`; wallets without events leave it out. */
+    on?(event: string, listener: (...args: unknown[]) => void): unknown;
+    removeListener?(event: string, listener: (...args: unknown[]) => void): unknown;
+};
+/** The legacy injected Solana shape Phantom, Solflare and Backpack expose. */
+type SolanaInjectedProvider = {
+    connect(): Promise<unknown>;
+    publicKey?: {
+        toBase58(): string;
+    } | null;
+    signMessage(message: Uint8Array, display?: "utf8"): Promise<{
+        signature: Uint8Array;
+    } | Uint8Array>;
+};
+/** The part of a Wallet Standard account Relay uses. */
+type StandardWalletAccount = {
+    readonly address: string;
+    readonly chains: readonly string[];
+};
+/** The part of a Wallet Standard wallet Relay uses; any conforming wallet object fits. */
+type StandardWallet = {
+    readonly name: string;
+    readonly icon?: string;
+    readonly chains: readonly string[];
+    readonly accounts: readonly StandardWalletAccount[];
+    readonly features: Readonly<Record<string, unknown>>;
+};
+/** Keplr's API, which Leap and Cosmostation also implement. */
+type KeplrLike = {
+    enable(chainId: string | string[]): Promise<void>;
+    getKey(chainId: string): Promise<{
+        bech32Address: string;
+    }>;
+    signArbitrary(chainId: string, signer: string, data: string): Promise<{
+        signature: string;
+        pub_key: {
+            type: string;
+            value: string;
+        };
+    }>;
+    /** Adds a chain the wallet does not know, after the user approves it. */
+    experimentalSuggestChain?(chainInfo: CosmosChain["chainInfo"]): Promise<void>;
+};
+/** A wallet found in the page, ready to pass to `relay.wallets.link`. */
+type DiscoveredWallet = {
+    id: string;
+    name: string;
+    icon?: string;
+    signer: WalletSigner;
+};
+/** Signs with an EIP-1193 provider through `personal_sign`. */
+declare function evmSigner(provider: Eip1193Provider, info?: {
+    name?: string;
+}): WalletSigner;
+/** Signs with a legacy injected Solana provider, such as `window.phantom.solana`. */
+declare function solanaSigner(provider: SolanaInjectedProvider, info?: {
+    name?: string;
+}): WalletSigner;
+/** Signs with a Wallet Standard wallet's `solana:signMessage` feature. */
+declare function walletStandardSolanaSigner(wallet: StandardWallet): WalletSigner;
+/**
+ * Signs an ADR-36 message with Keplr or a wallet that implements its API, on the app's chain:
+ * `{ chainId, chainInfo? }` or `"cosmos:<chain ID>"`. When the wallet does not know the chain and
+ * `chainInfo` is given, it suggests the chain to the wallet (`experimentalSuggestChain`) and tries
+ * again; without `chainInfo`, or with a wallet that cannot add chains, it throws an error that
+ * names the chain. Other failures, such as a rejected request, pass through.
+ */
+declare function cosmosSigner(provider: KeplrLike, chain: CosmosChain | CosmosNetwork, info?: {
+    name?: string;
+}): WalletSigner;
+/** EIP-6963 wallets, or `window.ethereum` when none announce themselves within `timeoutMs`. */
+declare function discoverEvmWallets(timeoutMs?: number): Promise<DiscoveredWallet[]>;
+/** Wallet Standard wallets that can sign Solana messages, then legacy injected providers. */
+declare function discoverSolanaWallets(): DiscoveredWallet[];
+/**
+ * Keplr, Leap and Cosmostation, each signing on the app's chain (see `cosmosSigner`). IDs end with
+ * the chain ID.
+ */
+declare function discoverCosmosWallets(chain: CosmosChain | CosmosNetwork): DiscoveredWallet[];
+/**
+ * The Cosmos SDK chains an app offers wallets on: one chain or several, each as
+ * `{ chainId, chainInfo? }` or `"cosmos:<chain ID>"`. Relay has no chain list of its own.
+ */
+type CosmosChains = CosmosChain | CosmosNetwork | readonly (CosmosChain | CosmosNetwork)[];
+/** The chains in `CosmosChains`, as a list. */
+declare function cosmosChainList(chains: CosmosChains | undefined): (CosmosChain | CosmosNetwork)[];
+/** An installed wallet that can sign in on one of the project's enabled wallet families. */
+type SignInWallet = DiscoveredWallet & {
+    network: WalletSignInNetwork;
+};
+/**
+ * The wallets installed in this browser that can sign in with `families`: EVM wallets first, then
+ * Solana wallets, then Cosmos wallets once per chain in `cosmos`. Without `cosmos` there are no
+ * Cosmos wallets. Empty during SSR.
+ */
+declare function discoverSignInWallets(families: readonly WalletSignInNetwork[], cosmos?: CosmosChains): Promise<SignInWallet[]>;
+
+export { type CosmosChains as C, type DiscoveredWallet as D, type Eip1193Provider as E, type KeplrLike as K, type SignInWallet as S, type SolanaInjectedProvider as a, type StandardWallet as b, type StandardWalletAccount as c, cosmosChainList as d, cosmosSigner as e, discoverCosmosWallets as f, discoverEvmWallets as g, discoverSignInWallets as h, discoverSolanaWallets as i, evmSigner as j, solanaSigner as s, walletStandardSolanaSigner as w };