@domino-sdk/relay 1.56.0 → 1.60.0

package/dist/wallet-DZWL7lJH.d.ts

@@ -0,0 +1,972 @@
+import * as z from 'zod';
+
+/** Who sees profiles: nobody but the member (`private`), signed-in members, or anyone. */
+declare const profileVisibilitySchema: z.ZodEnum<{
+    public: "public";
+    private: "private";
+    participants: "participants";
+}>;
+type ProfileVisibility = z.infer<typeof profileVisibilitySchema>;
+/** Connected accounts a member can take a picture from. */
+declare const avatarProviderSchema: z.ZodEnum<{
+    discord: "discord";
+    google: "google";
+    x: "x";
+}>;
+type AvatarProvider = z.infer<typeof avatarProviderSchema>;
+/**
+ * The accounts that can supply a default name and picture: public personas. Google and Apple
+ * accounts are usually a legal name and a personal photo, so they never do.
+ */
+declare const profileDefaultProviderSchema: z.ZodEnum<{
+    discord: "discord";
+    x: "x";
+}>;
+type ProfileDefaultProvider = z.infer<typeof profileDefaultProviderSchema>;
+/**
+ * Where a profile's name and picture come from before the member chooses: the first of these
+ * accounts the member connected that has one, in order. Empty means generated values.
+ */
+declare const profileDefaultsSchema: z.ZodArray<z.ZodEnum<{
+    discord: "discord";
+    x: "x";
+}>>;
+type ProfileDefaults = z.infer<typeof profileDefaultsSchema>;
+/**
+ * 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.
+ */
+declare const avatarSeedSchema: z.ZodString;
+/**
+ * A profile's avatar: an uploaded picture, an account's picture, or a generated one. Every kind
+ * carries the generated avatar's `seed`, so a picture that fails to load falls back to the same
+ * generated avatar everywhere.
+ */
+declare const profileAvatarSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    source: z.ZodLiteral<"upload">;
+    url: z.ZodString;
+    seed: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"account">;
+    provider: z.ZodEnum<{
+        discord: "discord";
+        google: "google";
+        x: "x";
+    }>;
+    url: z.ZodString;
+    seed: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    source: z.ZodLiteral<"generated">;
+    seed: z.ZodString;
+}, z.core.$strip>], "source">;
+type ProfileAvatar = z.infer<typeof profileAvatarSchema>;
+/** What other participants see: the profile's public ID, its name and its avatar. */
+declare const profileSummarySchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"upload">;
+        url: z.ZodString;
+        seed: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"account">;
+        provider: z.ZodEnum<{
+            discord: "discord";
+            google: "google";
+            x: "x";
+        }>;
+        url: z.ZodString;
+        seed: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"generated">;
+        seed: z.ZodString;
+    }, z.core.$strip>], "source">;
+}, z.core.$strip>;
+type ProfileSummary = z.infer<typeof profileSummarySchema>;
+/**
+ * A display name: NFC-normalized, whitespace collapsed and trimmed, 1 to 40 characters, with no
+ * control, zero-width or bidirectional formatting characters.
+ */
+declare const displayNameSchema: z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>;
+/**
+ * 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`.
+ */
+declare const profileUpdateSchema: z.ZodObject<{
+    displayName: z.ZodOptional<z.ZodNullable<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>>;
+    avatar: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"account">;
+        provider: z.ZodEnum<{
+            discord: "discord";
+            google: "google";
+            x: "x";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        source: z.ZodLiteral<"generated">;
+    }, z.core.$strict>], "source">>>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type ProfileUpdate = z.input<typeof profileUpdateSchema>;
+/** The signed-in member's own profile, with what they chose and what they can choose from. */
+declare const ownProfileSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"upload">;
+        url: z.ZodString;
+        seed: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"account">;
+        provider: z.ZodEnum<{
+            discord: "discord";
+            google: "google";
+            x: "x";
+        }>;
+        url: z.ZodString;
+        seed: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"generated">;
+        seed: z.ZodString;
+    }, z.core.$strip>], "source">;
+    displayName: z.ZodNullable<z.ZodString>;
+    avatarChoice: z.ZodEnum<{
+        default: "default";
+        account: "account";
+        upload: "upload";
+        generated: "generated";
+    }>;
+    avatarProvider: z.ZodNullable<z.ZodEnum<{
+        discord: "discord";
+        google: "google";
+        x: "x";
+    }>>;
+    hidden: z.ZodBoolean;
+    locked: z.ZodBoolean;
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        participants: "participants";
+    }>;
+    options: z.ZodArray<z.ZodObject<{
+        provider: z.ZodEnum<{
+            discord: "discord";
+            google: "google";
+            x: "x";
+        }>;
+        name: z.ZodNullable<z.ZodString>;
+        givenName: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+        imageUrl: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** @compat output */
+type OwnProfile = z.infer<typeof ownProfileSchema>;
+/** A page of a profile's quest completions: `limit` quests (default 20, at most 100) after `cursor`. */
+declare const profileCompletionQuerySchema: z.ZodObject<{
+    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    cursor: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type ProfileCompletionQuery = z.input<typeof profileCompletionQuerySchema>;
+/** A quest the member completed, grouped over its completions. */
+declare const profileCompletionSchema: z.ZodObject<{
+    quest: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    completions: z.ZodNumber;
+    lastCompletedAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+type ProfileCompletion = z.infer<typeof profileCompletionSchema>;
+/**
+ * A profile's completions of the quests that show on profiles (`defineQuest({ profile: { visible:
+ * true } })`), most recently completed first. Pass `nextCursor` as `cursor` for the next page.
+ */
+declare const profileCompletionPageSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        quest: z.ZodString;
+        key: z.ZodOptional<z.ZodString>;
+        title: z.ZodString;
+        completions: z.ZodNumber;
+        lastCompletedAt: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>;
+    nextCursor: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type ProfileCompletionPage = z.infer<typeof profileCompletionPageSchema>;
+/** A profile's progress in one referral program: counts only, never codes or accounts. */
+declare const profileReferralSchema: z.ZodObject<{
+    program: z.ZodString;
+    key: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    invited: z.ZodNumber;
+    qualified: z.ZodNumber;
+    milestones: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        count: z.ZodNumber;
+        reached: z.ZodBoolean;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type ProfileReferral = z.infer<typeof profileReferralSchema>;
+/** A project's profile settings in one environment. */
+declare const profileSettingsSchema: z.ZodObject<{
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        participants: "participants";
+    }>;
+    defaults: z.ZodArray<z.ZodEnum<{
+        discord: "discord";
+        x: "x";
+    }>>;
+    revision: z.ZodNumber;
+    actor: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strip>;
+type ProfileSettings = z.infer<typeof profileSettingsSchema>;
+declare const profileSettingsInputSchema: z.ZodObject<{
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        participants: "participants";
+    }>;
+    defaults: z.ZodArray<z.ZodEnum<{
+        discord: "discord";
+        x: "x";
+    }>>;
+    actionId: z.ZodString;
+    expectedRevision: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strict>;
+type ProfileSettingsInput = z.input<typeof profileSettingsInputSchema>;
+/** An operator's change to a member's profile. Every action is audited with its reason. */
+declare const profileModerationSchema: z.ZodObject<{
+    actionId: z.ZodString;
+    resetName: z.ZodDefault<z.ZodBoolean>;
+    removeAvatar: z.ZodDefault<z.ZodBoolean>;
+    lock: z.ZodOptional<z.ZodBoolean>;
+    reason: z.ZodString;
+}, z.core.$strict>;
+type ProfileModeration = z.input<typeof profileModerationSchema>;
+/** A member's profile as operators see it: always, whatever the settings. */
+declare const managedProfileSchema: z.ZodObject<{
+    name: z.ZodString;
+    id: z.ZodString;
+    displayName: z.ZodNullable<z.ZodString>;
+    hidden: z.ZodBoolean;
+    visibility: z.ZodEnum<{
+        public: "public";
+        private: "private";
+        participants: "participants";
+    }>;
+    locked: z.ZodBoolean;
+    avatar: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        source: z.ZodLiteral<"upload">;
+        url: z.ZodString;
+        seed: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"account">;
+        provider: z.ZodEnum<{
+            discord: "discord";
+            google: "google";
+            x: "x";
+        }>;
+        url: z.ZodString;
+        seed: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        source: z.ZodLiteral<"generated">;
+        seed: z.ZodString;
+    }, z.core.$strip>], "source">;
+    avatarChoice: z.ZodEnum<{
+        default: "default";
+        account: "account";
+        upload: "upload";
+        generated: "generated";
+    }>;
+    avatarProvider: z.ZodNullable<z.ZodEnum<{
+        discord: "discord";
+        google: "google";
+        x: "x";
+    }>>;
+    member: z.ZodString;
+    lockedAt: z.ZodNullable<z.ZodNumber>;
+    lockedBy: z.ZodNullable<z.ZodString>;
+    lockedReason: z.ZodNullable<z.ZodString>;
+    updatedAt: z.ZodNumber;
+}, z.core.$strip>;
+type ManagedProfile = z.infer<typeof managedProfileSchema>;
+/** The largest avatar upload, and the types an upload can have. */
+declare const AVATAR_UPLOAD_LIMIT: number;
+declare const avatarUploadTypes: string[];
+
+declare const solanaAddressSchema: z.ZodString;
+/** A wallet's chain family: its CAIP-2 namespace. */
+declare const walletChainSchema: z.ZodEnum<{
+    solana: "solana";
+    eip155: "eip155";
+    cosmos: "cosmos";
+}>;
+type WalletChain = z.infer<typeof walletChainSchema>;
+/**
+ * A Cosmos SDK chain's CAIP-2 ID: `cosmos:` and the chain ID, such as `cosmos:cosmoshub-4`. Relay
+ * accepts any chain ID in CAIP-2 reference syntax; the app decides which chains it works with.
+ */
+type CosmosNetwork = `cosmos:${string}`;
+declare const cosmosNetworkSchema: z.ZodCustom<`cosmos:${string}`, `cosmos:${string}`>;
+/** A Cosmos SDK bank denomination: 3–128 characters in the SDK's canonical denom syntax. */
+type CosmosDenom = string;
+declare const cosmosDenomSchema: z.ZodString;
+/**
+ * A Cosmos SDK chain an app works with. Pass `chainInfo` (Keplr's `ChainInfo` shape) for a chain
+ * wallets may not know: the adapters suggest it to the wallet (`experimentalSuggestChain`).
+ */
+type CosmosChain = {
+    /** The chain ID, such as `"cosmoshub-4"`. */
+    chainId: string;
+    chainInfo?: {
+        chainId: string;
+    } & Record<string, unknown>;
+};
+/** Reads the chain an app passes, a `CosmosChain` or its CAIP-2 ID, and adds the CAIP-2 ID. */
+declare function cosmosChain(chain: CosmosChain | CosmosNetwork): CosmosChain & {
+    network: CosmosNetwork;
+};
+/** The CAIP-2 ID of Solana mainnet (its genesis hash, truncated to 32 characters). */
+declare const solanaMainnet = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+declare const evmAddressSchema: z.ZodString;
+/** Bech32 with any prefix, in one case. The server checks the checksum and stores lowercase. */
+declare const cosmosAddressSchema: z.ZodString;
+/** What the wallet says its address is. The server checks the format and canonicalises it (EIP-55, lowercase bech32). */
+declare const walletAddressInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    chain: z.ZodLiteral<"solana">;
+    address: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    chain: z.ZodLiteral<"eip155">;
+    address: z.ZodString;
+    chainId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    chain: z.ZodLiteral<"cosmos">;
+    network: z.ZodCustom<`cosmos:${string}`, `cosmos:${string}`>;
+    address: z.ZodString;
+}, z.core.$strict>], "chain">;
+type WalletAddressInput = z.input<typeof walletAddressInputSchema>;
+/** Not strict: newer servers may add fields. */
+declare const walletMessageChallengeSchema: z.ZodObject<{
+    id: z.ZodString;
+    purpose: z.ZodEnum<{
+        link: "link";
+        "sign-in": "sign-in";
+    }>;
+    chain: z.ZodEnum<{
+        solana: "solana";
+        eip155: "eip155";
+        cosmos: "cosmos";
+    }>;
+    network: z.ZodNullable<z.ZodCustom<`cosmos:${string}`, `cosmos:${string}`>>;
+    address: z.ZodString;
+    message: z.ZodString;
+    expiresAt: z.ZodNumber;
+}, z.core.$strip>;
+type WalletMessageChallenge = z.infer<typeof walletMessageChallengeSchema>;
+declare const walletSignatureSchema: z.ZodObject<{
+    challenge: z.ZodString;
+    signature: z.ZodString;
+    publicKey: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type WalletSignature = z.infer<typeof walletSignatureSchema>;
+declare const linkedWalletSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        solana: "solana";
+        eip155: "eip155";
+        cosmos: "cosmos";
+    }>;
+    network: z.ZodNullable<z.ZodCustom<`cosmos:${string}`, `cosmos:${string}`>>;
+    address: z.ZodString;
+    verifiedAt: z.ZodNumber;
+    revision: z.ZodNumber;
+    signIn: z.ZodBoolean;
+}, z.core.$strip>;
+type LinkedWallet = z.infer<typeof linkedWalletSchema>;
+declare const walletUnlinkInputSchema: z.ZodObject<{
+    chain: z.ZodEnum<{
+        solana: "solana";
+        eip155: "eip155";
+        cosmos: "cosmos";
+    }>;
+    address: z.ZodString;
+}, z.core.$strict>;
+type WalletUnlinkInput = z.infer<typeof walletUnlinkInputSchema>;
+/**
+ * A wallet that can prove control of an address. `@domino-sdk/relay/browser` has adapters for
+ * injected EVM, Solana and Keplr-style wallets; tests and servers can implement it directly.
+ */
+type WalletSigner = {
+    readonly chain: WalletChain;
+    /** Required when `chain` is `"cosmos"`: the app's chain, `cosmos:<chain ID>`. */
+    readonly network?: CosmosNetwork;
+    /** For UI, such as "Phantom". */
+    readonly name?: string;
+    /** Connect if needed and return the address to challenge. */
+    address(): Promise<string>;
+    /** EVM only: the wallet's current chain, shown in the message's Chain ID line. */
+    chainId?(): Promise<number>;
+    /** Sign the exact UTF-8 message and return the encoding `walletSignatureSchema` documents. */
+    sign(message: string, address: string): Promise<{
+        signature: string;
+        publicKey?: string;
+    }>;
+};
+/** Builds the challenge input for a signer's address. */
+declare function walletAddressInput(signer: WalletSigner): Promise<WalletAddressInput>;
+/**
+ * The most wallets of one chain family a member can have linked to one project at a time. Sign-in
+ * wallets do not count: signing in always links the wallet.
+ */
+declare const WALLETS_PER_CHAIN = 5;
+/** The wallet families a project can enable for sign-in, in their stored order. */
+declare const walletSignInFamilies: readonly ["solana", "eip155", "cosmos"];
+/**
+ * What a project enables wallet sign-in for: a chain family. A Cosmos wallet signs in on any
+ * Cosmos SDK chain the app offers. Off unless the project enables it.
+ */
+declare const walletSignInNetworkSchema: z.ZodEnum<{
+    solana: "solana";
+    eip155: "eip155";
+    cosmos: "cosmos";
+}>;
+type WalletSignInNetwork = (typeof walletSignInFamilies)[number];
+/** Enabled wallet families, once each, in their stored order. */
+declare const walletSignInNetworksSchema: z.ZodPipe<z.ZodArray<z.ZodEnum<{
+    solana: "solana";
+    eip155: "eip155";
+    cosmos: "cosmos";
+}>>, z.ZodTransform<("solana" | "eip155" | "cosmos")[], ("solana" | "eip155" | "cosmos")[]>>;
+/** The sign-in setting a wallet account falls under: its chain family. */
+declare function walletSignInNetwork(wallet: Pick<LinkedWallet, "chain" | "network">): WalletSignInNetwork;
+/**
+ * The CAIP-10 account ID of a wallet on one network. Linked Solana and EVM wallets are
+ * chain-agnostic, so pass the network you mean; the defaults are Solana mainnet and Ethereum
+ * (`eip155:1`). A Cosmos wallet always uses the network it was linked on.
+ */
+declare function caip10(wallet: Pick<LinkedWallet, "chain" | "network" | "address">, network?: string): string;
+/** An EVM chain's CAIP-2 ID: `eip155:` and the chain ID in decimal, such as `"eip155:8453"` (Base). */
+type EvmChainId = `eip155:${number}`;
+/**
+ * Whether `value` is an EVM CAIP-2 ID in canonical form (no leading zeros, at most 16 digits).
+ * Syntax only: the chains Relay reads balances on are the platform's to list
+ * (`management.walletBalanceChains()`).
+ */
+declare function isEvmChainId(value: string): value is EvmChainId;
+/** {@link isEvmChainId} as a schema. */
+declare const evmChainIdSchema: z.ZodCustom<`eip155:${number}`, `eip155:${number}`>;
+/** What `ctx.wallet.balance()` reads. Omit `token` for a Solana or EVM native coin. */
+type WalletBalanceQuery = {
+    /** Solana mainnet: `"solana"` or its CAIP-2 ID. */
+    chain: "solana" | typeof solanaMainnet;
+    /** An SPL or Token-2022 mint address (base58). */
+    token?: string;
+    /** One of the member's linked Solana wallets; omit to read all of them. */
+    address?: string;
+} | {
+    /**
+     * An EVM chain's CAIP-2 ID, such as `"eip155:8453"` for Base. The platform reads the chains
+     * `management.walletBalanceChains()` lists, and fails the evaluation on any other.
+     */
+    chain: EvmChainId;
+    /** An ERC-20 contract address. */
+    token?: `0x${string}`;
+    /** One of the member's linked EVM wallets; omit to read all of them. */
+    address?: string;
+} | {
+    /** A Cosmos SDK chain's CAIP-2 ID. Relay reads the chains its management API lists. */
+    chain: CosmosNetwork;
+    /** The bank denomination to read, such as `uatom` or `uosmo`. */
+    token: CosmosDenom;
+    /** One of the member's wallets linked on this exact Cosmos network; omit to read all. */
+    address?: string;
+};
+/** A balance read for the member's pinned linked wallets, in raw integer units. */
+declare const walletBalanceSchema: z.ZodObject<{
+    chain: z.ZodString;
+    token: z.ZodNullable<z.ZodString>;
+    decimals: z.ZodNullable<z.ZodNumber>;
+    total: z.ZodString;
+    wallets: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        amount: z.ZodString;
+    }, z.core.$strict>>;
+    at: z.ZodObject<{
+        kind: z.ZodEnum<{
+            slot: "slot";
+            block: "block";
+        }>;
+        number: z.ZodString;
+    }, z.core.$strict>;
+    observedAt: z.ZodNumber;
+}, z.core.$strict>;
+type WalletBalance = z.infer<typeof walletBalanceSchema>;
+
+/**
+ * One wallet's balance as Relay sampled it for a `wallet.balances()` tracker, the record's `data`.
+ * The record's ID and author are the wallet's CAIP-10 account on the sampled chain, and its
+ * `occurredAt` is when Relay sampled it.
+ *
+ * @compat output
+ */
+declare const walletBalanceSampleSchema: z.ZodObject<{
+    amount: z.ZodString;
+    decimals: z.ZodNullable<z.ZodNumber>;
+    block: z.ZodString;
+}, z.core.$strip>;
+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;
+/**
+ * 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.
+ */
+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 mainnet: the Metaplex collection NFT's mint, `"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp/nft:<mint>"`,
+ * which stands for every NFT whose metadata names that collection as verified.
+ */
+type NftCollection = `${EvmChainId}/erc721:0x${string}` | `${EvmChainId}/erc1155:0x${string}/${string}` | `${typeof solanaMainnet}/nft:${string}`;
+/** The parts of an NFT collection ({@link parseNftCollection}). */
+type NftCollectionParts = {
+    chain: EvmChainId;
+    standard: "erc721" | "erc1155";
+    contract: `0x${string}`;
+    tokenId: string | null;
+} | {
+    chain: typeof solanaMainnet;
+    standard: "metaplex";
+    /** The Metaplex collection NFT's mint (base58). */
+    mint: string;
+};
+/**
+ * The parts of an NFT collection, or null when `value` is not one: an ERC-721 collection has no
+ * token ID, an ERC-1155 one has a token ID that fits in 256 bits, and a Solana collection names a
+ * base58 mint. Syntax only: the chains, contracts and mints Relay reads are checked when the
+ * collection is set.
+ */
+declare function parseNftCollection(value: string): NftCollectionParts | null;
+/** Whether `value` is an NFT collection `ctx.wallet.nfts()` takes ({@link parseNftCollection}). */
+declare function isNftCollection(value: string): value is NftCollection;
+/** What `ctx.wallet.nfts()` reads. */
+type WalletNftsQuery = {
+    /** The collection, from a `settings.nft()` setting: never from member input. */
+    collection: NftCollection;
+    /** One of the member's linked wallets of the collection's family; omit to read all of them. */
+    address?: string;
+};
+/** The NFTs of one collection the member's pinned linked wallets hold. */
+declare const walletNftsSchema: z.ZodObject<{
+    collection: z.ZodString;
+    chain: z.ZodString;
+    standard: z.ZodEnum<{
+        erc721: "erc721";
+        erc1155: "erc1155";
+        metaplex: "metaplex";
+    }>;
+    total: z.ZodString;
+    wallets: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        count: z.ZodString;
+    }, z.core.$strict>>;
+    at: z.ZodObject<{
+        kind: z.ZodEnum<{
+            slot: "slot";
+            block: "block";
+        }>;
+        number: z.ZodString;
+    }, z.core.$strict>;
+    observedAt: z.ZodNumber;
+}, z.core.$strict>;
+type WalletNfts = z.infer<typeof walletNftsSchema>;
+/** 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}). */
+type ContractFunction = {
+    name: string;
+    /** Each parameter's canonical ABI type, such as `"address"` or `"uint256"`. */
+    inputs: string[];
+    /** The return value's canonical ABI type. */
+    returns: ContractCallReturnType;
+    mutability: "view" | "pure";
+    /** The canonical signature, such as `"function stakedOf(address) view returns (uint256)"`. */
+    signature: string;
+};
+/**
+ * A human-readable ABI signature of a function `ctx.wallet.call()` can read, such as
+ * `"function stakedOf(address account) view returns (uint256)"`, or null when it is not one: the
+ * function must be `view` or `pure`, take elementary parameters (`address`, `bool`, `string`,
+ * `bytes`, `bytesN`, `uintN`, `intN`), and return exactly one `uint`, `int`, `bool` or `address`.
+ * Arrays, tuples, structs and several return values are refused.
+ */
+declare function parseContractFunction(signature: string): ContractFunction | null;
+/**
+ * A contract function on an EVM chain, as a `settings.contractCall()` setting holds it: the
+ * contract's CAIP-10 account ID, a space, and the function's human-readable signature, such as
+ * `"eip155:8453:0x… function stakedOf(address) view returns (uint256)"`.
+ */
+type ContractCall = `${EvmChainId}:0x${string} function ${string}`;
+/** The parts of a contract call ({@link parseContractCall}). */
+type ContractCallParts = {
+    chain: EvmChainId;
+    contract: `0x${string}`;
+    function: ContractFunction;
+};
+/**
+ * The parts of a contract call, or null when `value` is not one ({@link parseContractFunction}).
+ * Syntax only: the chain is checked when the setting is published or edited.
+ */
+declare function parseContractCall(value: string): ContractCallParts | null;
+/** Whether `value` is a contract call `ctx.wallet.call()` takes ({@link parseContractCall}). */
+declare function isContractCall(value: string): value is ContractCall;
+/**
+ * One argument of a contract call: a literal or a setting's value, or `{ wallet: true }` for the
+ * member's wallet address, read once per linked wallet. Integers may be numbers or decimal strings.
+ */
+type WalletCallArgument = {
+    wallet: true;
+} | string | number | boolean;
+/** What `ctx.wallet.call()` reads. */
+type WalletCallQuery = {
+    /** The contract and function, from a `settings.contractCall()` setting: never from member input. */
+    call: ContractCall;
+    /**
+     * The function's arguments, in order. `{ wallet: true }` may fill at most one `address`
+     * parameter; the other values come from settings or code, never from member input.
+     */
+    args?: WalletCallArgument[];
+    /** One of the member's linked EVM wallets; omit to read all of them. */
+    address?: string;
+};
+/** A contract view call, once per pinned linked EVM wallet, at one block. */
+declare const walletCallSchema: z.ZodObject<{
+    call: z.ZodString;
+    chain: z.ZodString;
+    contract: z.ZodString;
+    returns: z.ZodString;
+    total: z.ZodNullable<z.ZodString>;
+    wallets: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        value: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>;
+    }, z.core.$strict>>;
+    at: z.ZodObject<{
+        kind: z.ZodEnum<{
+            block: "block";
+        }>;
+        number: z.ZodString;
+    }, z.core.$strict>;
+    observedAt: z.ZodNumber;
+}, z.core.$strict>;
+type WalletCall = z.infer<typeof walletCallSchema>;
+/** What `ctx.wallet.delegations()` reads. */
+type WalletDelegationsQuery = {
+    /** A Cosmos SDK chain's CAIP-2 ID. Relay reads the chains its management API lists. */
+    chain: CosmosNetwork;
+    /** A validator's operator address (bech32, such as `cosmosvaloper1…`); omit to count every validator. */
+    validator?: string;
+    /** One of the member's wallets linked on this exact Cosmos network; omit to read all. */
+    address?: string;
+};
+/** The member's native staking delegations on one Cosmos SDK chain, at one block. */
+declare const walletDelegationsSchema: z.ZodObject<{
+    chain: z.ZodString;
+    denom: z.ZodString;
+    validator: z.ZodNullable<z.ZodString>;
+    total: z.ZodString;
+    wallets: z.ZodArray<z.ZodObject<{
+        address: z.ZodString;
+        amount: z.ZodString;
+    }, z.core.$strict>>;
+    validators: z.ZodArray<z.ZodObject<{
+        validator: z.ZodString;
+        amount: z.ZodString;
+    }, z.core.$strict>>;
+    at: z.ZodObject<{
+        kind: z.ZodEnum<{
+            block: "block";
+        }>;
+        number: z.ZodString;
+    }, z.core.$strict>;
+    observedAt: z.ZodNumber;
+}, z.core.$strict>;
+type WalletDelegations = z.infer<typeof walletDelegationsSchema>;
+/**
+ * An EVM contract event a quest checks, as `settings.contractEvent()` holds it: the contract as a
+ * CAIP-10 account ID, a space, and the event's Solidity signature with argument names and
+ * `indexed` markers, such as
+ * `"eip155:8453:0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 Transfer(address indexed from, address indexed to, uint256 value)"`.
+ * A leading `event` keyword is accepted.
+ */
+type ContractEvent = `${EvmChainId}:0x${string} ${string}`;
+/** One argument of a {@link ContractEvent}'s signature. */
+type ContractEventInput = {
+    name: string;
+    /** The Solidity type in canonical form: `uint` reads as `uint256`, `int` as `int256`. */
+    type: string;
+    indexed: boolean;
+};
+/** The parts of a {@link ContractEvent} ({@link parseContractEvent}). */
+type ContractEventParts = {
+    chain: EvmChainId;
+    contract: `0x${string}`;
+    /** The event name, such as `"Transfer"`. */
+    name: string;
+    inputs: ContractEventInput[];
+    /** The canonical signature the event's topic hashes: `"Transfer(address,address,uint256)"`. */
+    signature: string;
+};
+/**
+ * The parts of a contract event, or null when `value` is not one. Every argument is named, names
+ * are unique, at most three are `indexed`, and at least one indexed argument is an `address`: the
+ * one `ctx.wallet.events()` matches against the member's wallets. Tuples and arrays of arrays are
+ * not supported.
+ * Syntax only: the chains Relay reads are checked when the event is set.
+ */
+declare function parseContractEvent(value: string): ContractEventParts | null;
+/** Whether `value` is a contract event `ctx.wallet.events()` takes ({@link parseContractEvent}). */
+declare function isContractEvent(value: string): value is ContractEvent;
+/**
+ * A condition on one event argument: equal to a value (an address in any case, an integer in
+ * decimal, a `bool`, or `bytes` in hex), or `{ gte }`, an integer argument at least a decimal value.
+ */
+type WalletEventCondition = string | boolean | {
+    gte: string;
+};
+/** The most logs one `ctx.wallet.events()` read may match before `where` filters them. */
+declare const maxWalletEventLogs = 1000;
+/** How far before the evaluation `ctx.wallet.events()` may look back: 30 days. */
+declare const maxWalletEventLookback: number;
+/** What `ctx.wallet.events()` reads. */
+type WalletEventsQuery = {
+    /** The contract and event, from a `settings.contractEvent()` setting: never from member input. */
+    event: ContractEvent;
+    /**
+     * The name of the event's indexed `address` argument that must be one of the member's linked
+     * EVM wallets, such as `"to"` for a `Transfer` the member received.
+     */
+    account: string;
+    /**
+     * The earliest block time read, in epoch milliseconds. At most 30 days before the evaluation
+     * ({@link maxWalletEventLookback}); an earlier time throws `author-error`.
+     */
+    since: number;
+    /** Also skip events before the quest was first activated in this environment. */
+    afterActivation?: boolean;
+    /** Conditions on other arguments, by name; every one must hold. */
+    where?: Record<string, WalletEventCondition>;
+    /** One of the member's linked EVM wallets; omit to read all of them. */
+    address?: string;
+};
+/**
+ * A decoded event argument: integers in decimal, addresses EIP-55, bytes in lowercase hex, and an
+ * array argument as an array of those.
+ */
+type WalletEventValue = string | boolean | (string | boolean)[];
+/** The events of one contract the member's pinned linked EVM wallets took part in. */
+declare const walletEventsSchema: z.ZodObject<{
+    event: z.ZodString;
+    chain: z.ZodString;
+    contract: z.ZodString;
+    since: z.ZodNumber;
+    at: z.ZodObject<{
+        kind: z.ZodEnum<{
+            block: "block";
+        }>;
+        number: z.ZodString;
+    }, z.core.$strict>;
+    finality: z.ZodEnum<{
+        finalized: "finalized";
+        safe: "safe";
+    }>;
+    logs: z.ZodArray<z.ZodObject<{
+        wallet: z.ZodString;
+        block: z.ZodString;
+        timestamp: z.ZodNumber;
+        tx: z.ZodString;
+        logIndex: z.ZodNumber;
+        args: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>, z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>>]>>;
+    }, z.core.$strict>>;
+    observedAt: z.ZodNumber;
+}, z.core.$strict>;
+type WalletEvents = z.infer<typeof walletEventsSchema>;
+/**
+ * A Solana program address on mainnet, as `settings.solanaProgram()` holds it: base58, 32 bytes,
+ * such as Jupiter's `"JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4"`.
+ */
+type SolanaProgram = string;
+/**
+ * Whether `value` is a Solana address `ctx.wallet.transactions()` takes as its program: base58 of
+ * 32 to 44 characters. Syntax only: Relay checks that the account is an executable program when
+ * the setting is saved and when it reads.
+ */
+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
+ * pasted or fetched.
+ */
+declare const anchorIdlSchema: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+type AnchorIdl = z.infer<typeof anchorIdlSchema>;
+/** @compat open */
+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
+ * program's on-chain IDL account when the setting was saved (`"chain"`), or pasted by an operator
+ * for a program without one (`"pasted"`).
+ */
+declare const solanaProgramIdlSchema: z.ZodObject<{
+    program: z.ZodString;
+    source: z.ZodType<SolanaIdlSource>;
+    idl: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>;
+type SolanaProgramIdl = z.infer<typeof solanaProgramIdlSchema>;
+/** The most transactions one `ctx.wallet.transactions()` read fetches per wallet. */
+declare const maxWalletTransactions = 1000;
+/** How far before the evaluation `ctx.wallet.transactions()` may look back: 30 days. */
+declare const maxWalletTransactionLookback: number;
+/** What `ctx.wallet.transactions()` reads. */
+type WalletTransactionsQuery = {
+    /** The program, from a `settings.solanaProgram()` setting: never from member input. */
+    program: SolanaProgram;
+    /**
+     * The earliest block time read, in epoch milliseconds. At most 30 days before the evaluation
+     * ({@link maxWalletTransactionLookback}); an earlier time throws `author-error`.
+     */
+    since: number;
+    /** Also skip transactions before the quest was first activated in this environment. */
+    afterActivation?: boolean;
+    /**
+     * An SPL token mint: read only the transactions that touched each wallet's associated token
+     * account for it, usually far fewer than the wallet's whole history.
+     */
+    mint?: string;
+    /** One of the member's linked Solana wallets; omit to read all of them. */
+    address?: string;
+};
+/** One wallet's change of one token in a transaction ({@link WalletTransaction}). */
+type WalletBalanceChange = {
+    /** The SPL token mint, or `"SOL"` for lamports. */
+    mint: string;
+    /** The change in base units: positive when the wallet gained, negative when it spent. */
+    delta: string;
+};
+/**
+ * The successful, finalized Solana transactions of the member's pinned linked wallets that invoked
+ * one program.
+ */
+declare const walletTransactionsSchema: z.ZodObject<{
+    program: z.ZodString;
+    chain: z.ZodString;
+    mint: z.ZodNullable<z.ZodString>;
+    since: z.ZodNumber;
+    at: z.ZodObject<{
+        kind: z.ZodEnum<{
+            slot: "slot";
+        }>;
+        number: z.ZodString;
+    }, z.core.$strict>;
+    complete: z.ZodBoolean;
+    transactions: z.ZodArray<z.ZodObject<{
+        wallet: z.ZodString;
+        signature: z.ZodString;
+        slot: z.ZodString;
+        timestamp: z.ZodNumber;
+        signer: z.ZodDefault<z.ZodBoolean>;
+        programs: z.ZodArray<z.ZodString>;
+        balanceChanges: z.ZodArray<z.ZodObject<{
+            mint: z.ZodString;
+            delta: z.ZodString;
+        }, z.core.$strict>>;
+        instructions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            args: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+            accounts: z.ZodRecord<z.ZodString, z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    observedAt: z.ZodNumber;
+}, z.core.$strict>;
+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. */
+type WalletInstruction = NonNullable<WalletTransaction["instructions"]>[number];
+/**
+ * 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
+ * to `null` when the member has no linked wallet it can read, so a non-null list is never empty
+ * and a non-null balance covers at least one wallet. Provider failures throw `CapabilityError`
+ * with code `"provider-unavailable"`; they never read as a zero balance.
+ */
+interface WalletReader {
+    /** Every wallet the member has linked to this project, newest first within each chain. */
+    list(): Promise<LinkedWallet[] | null>;
+    /**
+     * The native or token balance of the member's linked wallets on one chain: all wallets of that
+     * family (or exact Cosmos network), or `address`. Null when the member has no linked wallet it
+     * can read. A chain Relay does not read, a malformed token, and an `address` the member never
+     * linked throw `CapabilityError` with code `"author-error"`.
+     */
+    balance(query: WalletBalanceQuery): Promise<WalletBalance | null>;
+    /**
+     * 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
+     * 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.
+     */
+    nfts?(query: WalletNftsQuery): Promise<WalletNfts | null>;
+    /**
+     * Calls one view or pure contract function once per linked EVM wallet, at one block, and decodes
+     * each result: an integer as a decimal string (with `total`, their sum), a bool, or an address.
+     * `{ wallet: true }` in `args` stands for each wallet's address. Use it for state a contract
+     * keeps in a mapping, such as `stakedOf(address)` or `getVotes(address)`; when staking mints a
+     * receipt token, read that token with `balance()`. Null when the member has no linked EVM wallet.
+     * A malformed call, arguments that do not fit the function, a revert (with its reason), 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 older test doubles compile.
+     */
+    call?(query: WalletCallQuery): Promise<WalletCall | null>;
+    /**
+     * The native staking delegations of the member's wallets linked on one Cosmos SDK chain, at one
+     * block, in base units of the chain's staking denomination: summed, per wallet and per validator,
+     * or only to `validator`. Null when the member has no wallet linked on that chain. A chain Relay
+     * does not read, a malformed validator 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 older test doubles compile.
+     */
+    delegations?(query: WalletDelegationsQuery): Promise<WalletDelegations | null>;
+    /**
+     * The events of one contract whose `account` argument is one of the member's linked EVM
+     * wallets, from `since` up to the chain's finalized block (its `safe` block on a chain without
+     * finality), oldest first. Null when the member has no linked EVM wallet. A malformed event, a
+     * chain Relay does not read, an `account` that is not an indexed `address` argument, a `where`
+     * on an unknown argument, a `since` more than 30 days before the evaluation, a read over too
+     * many blocks or more than 1,000 logs, and an `address` the member never linked throw
+     * `CapabilityError` with code `"author-error"`. Only events that name the member in an indexed
+     * argument can be read: a router or aggregator call where the member is only the transaction's
+     * sender cannot. Relay supplies it to every evaluation; it is optional only so that test
+     * doubles written before it keep compiling.
+     */
+    events?(query: WalletEventsQuery): Promise<WalletEvents | null>;
+    /**
+     * The successful, finalized Solana transactions of the member's linked Solana wallets since
+     * `since` that invoked `program`, in a top-level or inner instruction, oldest first, with each
+     * wallet's balance changes. With `mint`, only transactions that touched each wallet's associated
+     * token account for the mint are read. Each wallet's read stops at its newest 1,000
+     * transactions, with `complete: false`. Null when the member has no linked Solana wallet. A
+     * malformed program, an account that is not an executable program, a `mint` that is not a token
+     * mint, a `since` more than 30 days before the evaluation, 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.
+     */
+    transactions?(query: WalletTransactionsQuery): Promise<WalletTransactions | null>;
+}
+
+export { type WalletTransactionsQuery as $, type AvatarProvider as A, type NftCollectionParts as B, type CosmosChain as C, type NftStandard as D, type EvmChainId as E, type WalletBalance as F, type WalletBalanceChange as G, type WalletBalanceQuery as H, type WalletBalanceSample as I, type WalletCall as J, type WalletCallArgument as K, type LinkedWallet as L, type WalletCallQuery as M, type NftCollection as N, type OwnProfile as O, type ProfileAvatar as P, type WalletDelegations as Q, type WalletDelegationsQuery as R, type SolanaProgram as S, type WalletEventCondition as T, type WalletEventValue as U, type WalletEvents as V, type WalletAddressInput as W, type WalletEventsQuery as X, type WalletNfts as Y, type WalletNftsQuery as Z, type WalletTransactions as _, type CosmosNetwork as a, solanaProgramIdlSchema as a$, cosmosDenomSchema as a0, cosmosNetworkSchema as a1, isContractCall as a2, isContractEvent as a3, isEvmChainId as a4, isNftCollection as a5, isSolanaProgram as a6, maxWalletEventLogs as a7, maxWalletEventLookback as a8, maxWalletTransactionLookback as a9, type SolanaProgramIdl as aA, WALLETS_PER_CHAIN as aB, anchorIdlSchema as aC, avatarProviderSchema as aD, avatarSeedSchema as aE, avatarUploadTypes as aF, caip10 as aG, cosmosAddressSchema as aH, cosmosChain as aI, displayNameSchema as aJ, evmAddressSchema as aK, evmChainIdSchema as aL, managedProfileSchema as aM, ownProfileSchema as aN, profileAvatarSchema as aO, profileCompletionPageSchema as aP, profileCompletionQuerySchema as aQ, profileCompletionSchema as aR, profileDefaultProviderSchema as aS, profileDefaultsSchema as aT, profileModerationSchema as aU, profileSettingsInputSchema as aV, profileSettingsSchema as aW, profileSummarySchema as aX, profileVisibilitySchema as aY, solanaAddressSchema as aZ, solanaMainnet as a_, maxWalletTransactions as aa, parseContractCall as ab, parseContractEvent as ac, parseContractFunction as ad, parseNftCollection as ae, type SolanaIdlSource as af, profileUpdateSchema as ag, walletAddressInputSchema as ah, walletSignatureSchema as ai, profileReferralSchema as aj, linkedWalletSchema as ak, walletBalanceSchema as al, walletNftsSchema as am, walletCallSchema as an, walletDelegationsSchema as ao, walletEventsSchema as ap, walletTransactionsSchema as aq, AVATAR_UPLOAD_LIMIT as ar, type AnchorIdl as as, type KnownSolanaIdlSource as at, type ManagedProfile as au, type ProfileDefaultProvider as av, type ProfileDefaults as aw, type ProfileModeration as ax, type ProfileSettings as ay, type ProfileSettingsInput as az, type ProfileCompletion as b, walletAddressInput as b0, walletBalanceSampleSchema as b1, walletChainSchema as b2, walletMessageChallengeSchema as b3, walletSignInFamilies as b4, walletSignInNetwork as b5, walletSignInNetworkSchema as b6, walletSignInNetworksSchema as b7, walletUnlinkInputSchema as b8, 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 ContractCall as o, type ContractEvent as p, type WalletBalanceSourceQuery as q, type WalletTransaction as r, type WalletInstruction as s, type WalletReader as t, type ContractCallParts as u, type ContractCallReturnType as v, type ContractEventInput as w, type ContractEventParts as x, type ContractFunction as y, type CosmosDenom as z };